Memxus

Una memoria. Cada IA. Nada que instalar. Memxus funciona en Claude, ChatGPT, Cursor y Slack, y en cualquier aplicación que tu equipo use que necesite recordar (Notion, Linear/Jira, Gmail, Salesforce/HubSpot, Intercom, Zendesk, Google Drive, Confluence, GitHub). Sin extensión, sin configuración local, sin contexto repetido. Guarda una vez. Recuerda en todas partes.

GitHub

Prueba este MCPPatrocinado

Documentación

Memxus — Ingeniería de Contexto

Una capa de contexto. Cada IA.

Multiplica tu productividad dándole a cada IA el contexto adecuado.

Memxus lleva la Ingeniería de Contexto a todo tu flujo de trabajo con IA.

Guarda tus decisiones reales, preferencias y contexto de trabajo una sola vez. Encuéntralas en segundos y dale a Claude, Cursor, ChatGPT, Gemini o cualquier cliente MCP el contexto exacto que necesita para cada tarea.

Sin explicaciones repetidas. Sin empezar desde cero. Mejores respuestas, más rápido.

Servidor MCP de Glama Licencia: AGPL-3.0 Node 20+ Railway MCP Registro v1.2.1

Sitio web · Documentación · Conecta tu primera IA

Mira la demo de Memxus en YouTube

▶️ Mira la demo en YouTube · Página de demo

Memxus Context Engineering hub: save from anywhere, recall in any AI, control via Dashboard

remember a decision in Claude, recall it later in Cursor, get the exact answer back

El problema

Las herramientas de IA son poderosas, pero su productividad disminuye cuando no tienen el contexto adecuado.

Claude no sabe lo que sabe Cursor. Cursor no sabe lo que sabe ChatGPT. Tus decisiones de proyecto, preferencias, arquitectura y contexto de trabajo se repiten en cada herramienta y en cada conversación nueva.

Eso crea trabajo innecesario:

Reexplicar la misma información
Buscar entre repositorios, documentos y conversaciones
Corregir respuestas basadas en contexto faltante
Repetir decisiones técnicas y de producto
Empezar cada tarea de IA desde cero

Memxus resuelve esto mediante la Ingeniería de Contexto.

Guarda lo que importa una vez, encuéntralo en segundos y dale a cada IA el contexto exacto que necesita para la tarea.

El resultado es menos repetición, menos idas y vueltas, ejecución más rápida y mejores respuestas en todo tu flujo de trabajo con IA.

Guarda una decisión en Claude → recupérala en Cursor → reutilízala en ChatGPT.
¿Necesitas contexto más profundo? Conecta GitHub y Notion cuando estés listo.

¿Qué es Memxus?

Memxus es una Ingeniería de Contexto diseñada para multiplicar tu productividad dándole a cada IA el contexto adecuado.

Crea una capa de contexto compartida entre Claude, Cursor, ChatGPT, Gemini y cualquier cliente compatible con MCP.

El flujo de trabajo principal es simple:

remember lo que importa
recall desde cualquier IA
encuentra contexto relevante en segundos
dale a cada IA la información que necesita para producir una mejor respuesta

Conéctate una vez con OAuth y tus decisiones, preferencias y contexto de trabajo se vuelven portables en todo tu flujo de trabajo con IA — sin configuración local, explicaciones repetidas ni copiar y pegar entre herramientas.

Para contexto más profundo, Memxus también puede conectarse a fuentes de trabajo reales como GitHub y Notion. Repositorios, documentación, commits, pull requests, issues y páginas seleccionadas del espacio de trabajo se vuelven buscables junto con tu contexto guardado manualmente.

Los conectores de GitHub y Notion están activos en producción. Esta sincronización más profunda es opcional: Memxus aporta valor desde la primera decisión guardada.

Guarda una vez. Encuéntralo rápido. Dale a cada IA el contexto adecuado. Trabaja más rápido.

Por qué los desarrolladores usan Memxus

Guarda una vez, recupéralo en cada IA — deja de repetir tu stack, decisiones y preferencias entre Claude, Cursor y ChatGPT
Pregunta una vez — no más búsquedas en 5 herramientas para recordar por qué elegiste X
Mantén la arquitectura del proyecto y el contexto del stack disponibles entre Claude, Cursor y ChatGPT
Sincroniza GitHub y Notion en colecciones de proyecto unificadas — un contexto por repositorio
Deja de pegar el mismo contexto en cada sesión nueva de IA
Comparte contexto de equipo entre agentes y flujos de trabajo
Construye aplicaciones de IA con contexto persistente mediante MCP o API

Contexto real desde GitHub y Notion

Memxus lee tu trabajo real — no fragmentos de memoria genéricos. El contenido sincronizado se organiza en una colección unificada por proyecto: project:<slug>.

Qué se sincroniza

Fuente	Contenido indexado en el contexto
GitHub	Repos, READMEs, commits, pull requests, issues
Notion	Páginas y documentos seleccionados del espacio de trabajo
Manual	Decisiones, preferencias y notas mediante `remember`

Cómo conectarse

Panel de control — dashboard.memxus.com/integrations (GitHub App + Notion OAuth)
Desde el chat (MCP) — connect_source → check_connect_status → list_syncable_items → set_sync_selection

Cómo usar el contexto sincronizado

Llama a recall o get_context con collection=project:<slug> (o deja que la búsqueda semántica lo encuentre). El contenido de GitHub/Notion está etiquetado y es buscable junto con las memorias manuales.

flowchart LR
  Save["💾 Save — from any AI"] --> Memxus["🧠 Memxus — your persistent memory"] --> Recall["✨ Recall anywhere — Claude · Cursor · ChatGPT · Gemini"]

Empieza a guardar en un mensaje

Después de conectar Memxus a cualquier IA, pega una línea como esta — Memxus llama a remember y tu contexto queda disponible en todas partes:

Remember this in Memxus: we use Postgres + pgvector for semantic search.

No necesitas sincronización de GitHub/Notion para empezar. Sincroniza más tarde cuando quieras un contexto de proyecto más profundo.

Opcional — sincroniza todo tu stack: los repositorios de GitHub, páginas de Notion, archivos, documentos y decisiones se vuelven contexto recuperable también.

Herramientas del conector Context Engine (4): conecta GitHub/Notion desde el chat mediante MCP. La producción anuncia las 9 herramientas principales; las 4 herramientas del conector se habilitan por cuenta, por lo que un cliente recién conectado ve las 9 principales.

Conéctate en 1 segundo, con un clic

URL:       https://mcp.memxus.com/mcp
Auth:      OAuth 2.1 (handled automatically)
Transport: Streamable HTTP

Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "memxus": {
      "url": "https://mcp.memxus.com/mcp",
      "transport": "streamable-http"
    }
  }
}

Cursor / VS Code

{
  "mcp": {
    "servers": {
      "memxus": {
        "url": "https://mcp.memxus.com/mcp",
        "transport": "http"
      }
    }
  }
}

O abre directamente en Glama Inspector →
[https://glama.ai/mcp/inspector?url=https://mcp.memxus.com/mcp](https://glama.ai/mcp/inspector?url=https://mcp.memxus.com/mcp)

Para revisores del marketplace: consulta REVIEWER.md para la configuración de OAuth y token Bearer.

Plataformas compatibles

Plataforma	Integración	Estado
Claude Desktop / claude.ai	MCP remoto	✅ Activo
Cursor	MCP remoto	✅ Activo
VS Code / Copilot MCP	MCP remoto	✅ Activo
ChatGPT	GPT personalizado / API	✅ Activo
Gemini	Flujo de trabajo compatible con MCP	✅ Activo
Telegram	Conector de bot	✅ Activo
GitHub	Sincronización de repos (commits, PRs, issues, README)	✅ Activo
Notion	Sincronización de páginas del espacio de trabajo	✅ Activo
Discord	Conector de bot	🔜 Próximamente
Slack	Conector de bot	🔜 Próximamente
Cualquier cliente compatible con MCP	MCP remoto	✅ Activo

Herramientas disponibles

Registro com.memxus/memxus v1.2.1 — 9 herramientas principales siempre disponibles, más 4 herramientas de conector para la sincronización de GitHub/Notion desde el chat.

Herramientas principales (9)

Herramienta	Descripción
`remember`	Guarda contexto — entrada manual, decisiones o notas; colección `project:<slug>` opcional
`recall`	Búsqueda semántica entre memorias; contenido sincronizado de GitHub/Notion mediante `project:<slug>` o etiquetas
`get_context`	Bloque de contexto formateado desde GitHub, Notion y decisiones guardadas para prompts de agentes
`list_memories`	Explora memorias por colección, etiquetas, tipo o visibilidad
`get_memory`	Recupera contenido completo y metadatos por ID de memoria
`list_collections`	Lista ámbitos; las sincronizaciones de GitHub/Notion aparecen bajo `project:<slug>`
`forget`	Elimina una memoria permanentemente
`memory_stats`	Estadísticas por tipo y colección
`update`	Parchea o agrega contenido, etiquetas o tipo a una memoria existente

Herramientas del conector Context Engine (4) — v1.2.1

Herramienta	Descripción
`connect_source`	Inicia la instalación de GitHub App o el OAuth de Notion desde el chat
`list_syncable_items`	Lista repos o páginas de Notion disponibles después de conectar
`set_sync_selection`	Elige qué sincronizar y activa la sincronización inicial en `project:<slug>`
`check_connect_status`	Consulta el estado de la conexión después de `connect_source`

Referencia completa de herramientas: memxus.com/docs/mcp · Revisores del marketplace: REVIEWER.md

Arquitectura

GitHub App ──┐
Notion OAuth ┼──► sync (API + connector tools) ──► Supabase  project:<slug>
Manual MCP   ┘                                              │
                                                            │ pgvector
MCP Client (Claude, Cursor, etc.)                           │
        │                                                   │
        │  POST /mcp   Bearer aimem_*                       │
        ▼                                                   ▼
  mcp.memxus.com  ← This repo (Railway) ──────────►  Supabase (Postgres + pgvector)
        │
        ▼
  Dash-AIMemory (Dashboard + integrations)

La sincronización se ejecuta del lado del servidor mediante el panel de control o las herramientas del conector MCP — sin archivos locales que gestionar.

Transporte: HTTP Streamable (MCP 2.0)
Autenticación: OAuth 2.1 + PKCE + Registro Dinámico de Clientes (RFC 9728)

Seguridad

OAuth 2.1 + PKCE — sin contraseñas, sin claves API que gestionar
Cifrado en reposo (AES-256)
Memoria controlada por el usuario — visualiza, edita y elimina en cualquier momento desde el panel de control
Sin archivos locales ni sincronización manual
Auditoría de secretos previa a la publicación superada: 2026-06-17
La memoria es contexto de asesoramiento, no autoridad de instrucciones — consulta TRUST-POLICY.md para saber qué se lee automáticamente, qué requiere una escritura explícita y qué nunca hace la capa de memoria.

Flujo OAuth

1. Client  →  GET  /.well-known/oauth-authorization-server
2. Client  →  GET  /oauth/authorize  →  redirect to dashboard login
3. User signs in (Google) in the dashboard
4. Client  →  POST /oauth/token  (PKCE)  →  aimem_* bearer token
5. Client  →  POST /mcp  Authorization: Bearer aimem_*

Se admite el Registro Dinámico de Clientes — los clientes se registran automáticamente en la primera conexión.

Autoalojamiento

Requisitos previos

Node 20+
Proyecto Supabase (ejecuta supabase/migration.sql después de la migración del panel de control)
Cuenta de Railway (o cualquier host de Node)

Variables de entorno

cp .env.example .env

Variable	Descripción
`MCP_PUBLIC_URL`	URL pública de este servidor (sin barra final)
`DASHBOARD_URL`	URL de Dash-AIMemory para el redireccionamiento de inicio de sesión
`SUPABASE_URL`	URL del proyecto Supabase
`SUPABASE_SERVICE_ROLE_KEY`	Clave de rol de servicio de Supabase
`OAUTH_CLIENT_ID`	ID de cliente OAuth
`ALLOWED_REDIRECT_URIS`	URIs de redireccionamiento permitidas separadas por comas
`CORS_ORIGINS`	Orígenes CORS permitidos separados por comas
`OPENAI_API_KEY`	(Opcional) Embeddings de búsqueda vectorial

Ejecutar localmente

npm install
npm run dev       # tsx watch
npm run build     # tsc → dist/
npm start         # node dist/index.js

Desplegar en Railway

Configura todas las variables en Settings → Variables (nunca confirmes .env).
MCP_PUBLIC_URL = tu URL de red de Railway (sin /mcp final).
Endpoint de verificación de salud: /health (configurado en [railway.toml](railway.toml)).

Nota: Node 20 en Railway — Supabase Realtime necesita el paquete ws (configurado en src/lib/supabase.ts).
Opcional: configura RAILPACK_NODE_VERSION=22 para soporte nativo de WebSocket.

Desarrollo

npm install
npm run dev        # tsx watch
npm run lint       # ESLint
npm run typecheck  # tsc --noEmit
npm run build      # compile → dist/
npm start          # node dist/index.js

Revisores del marketplace: REVIEWER.md · Documentación de MCP: memxus.com/docs/mcp · Registro: com.memxus/memxus v1.2.1

Lanzamientos

Agrega entradas bajo ## [Unreleased] en [CHANGELOG.md](CHANGELOG.md)
Incrementa la versión en package.json, server.json, src/mcp/server.ts y src/mcp/public-discovery.ts
Mueve la sección del registro de cambios a ## [X.Y.Z] - YYYY-MM-DD
Confirma, etiqueta y envía:

git tag -a vX.Y.Z -m "Memxus MCP vX.Y.Z"
git push origin vX.Y.Z

Enviar una etiqueta v* activa [.github/workflows/release.yml](.github/workflows/release.yml) — puerta de calidad + Release de GitHub con server.json adjunto.

Auditoría de secretos

Ejecutar desde la raíz del repositorio antes de hacer público el repositorio.
Última auditoría: 2026-06-17 — APROBADO

# 1. Verify .env was never committed
git log --all --full-history -- .env .env.local .env.production

# 2. Check for .env* files added in history
git log --all --oneline --diff-filter=A -- "*.env*"

# 3. Grep current tree for dangerous patterns (exclude .example)
git grep -rn -E "(service_role|anon_key|sk-[a-zA-Z0-9]{20,}|aimem_[a-zA-Z0-9]+|eyJ[a-zA-Z0-9_-]{20,})" \
  -- ":(exclude)*.example" ":(exclude)CHANGELOG*"

# 4. Search full git history for leaked keys
git log --all -p --follow -S "service_role" -- . | head -100
git log --all -p --follow -S "SUPABASE_SERVICE_ROLE_KEY=" -- . | head -100

Verificación	Esperado
Comandos 1–2	Sin commits `.env` (solo `.env.example` en el commit inicial)
Comando 3	Solo placeholders (`aimem_YOUR_KEY`), fixtures de prueba, comentarios SQL
Comando 4	Sin valores de clave reales en los diffs

Si los comandos 1 o 4 encuentran secretos reales, rota las claves inmediatamente y ejecuta git filter-repo --path .env --invert-paths antes de publicar.

Hoja de ruta

Licencia

Licenciado bajo la GNU Affero General Public License v3.0 (AGPL-3.0).

Puedes usar, modificar y distribuir este código libremente. Si lo usas para ejecutar un servicio de red (SaaS), debes publicar tu código fuente bajo la misma licencia.

Memxus Remote MCP Server
Copyright (C) 2026 Gabriel Pitrella - Memxus