Memxus

Uma memória. Toda IA. Nada para instalar. Memxus funciona no Claude, ChatGPT, Cursor e Slack — e em qualquer aplicativo que sua equipe use e que precise lembrar (Notion, Linear/Jira, Gmail, Salesforce/HubSpot, Intercom, Zendesk, Google Drive, Confluence, GitHub). Sem extensão, sem configuração local, sem contexto repetido. Salve uma vez. Lembre-se em todos os lugares.

GitHub

Experimente este MCPPatrocinado

Documentação

Memxus — Engenharia de Contexto

Uma camada de contexto. Para toda IA.

Multiplique sua produtividade dando a cada IA o contexto certo.

Memxus leva Engenharia de Contexto para todo o seu fluxo de trabalho com IA.

Salve suas decisões reais, preferências e contexto de trabalho uma única vez. Encontre-os em segundos e dê a Claude, Cursor, ChatGPT, Gemini ou qualquer cliente MCP o contexto exato necessário para cada tarefa.

Sem explicações repetidas. Sem começar do zero. Respostas melhores, mais rápido.

Glama MCP Server License: AGPL-3.0 Node 20+ Railway MCP Registry v1.2.1

Site · Docs · Conecte sua primeira IA

Assista à demonstração do Memxus no YouTube

▶️ Assista à demonstração no YouTube · Página da demonstração

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

O problema

As ferramentas de IA são poderosas, mas sua produtividade cai quando não têm o contexto certo.

Claude não sabe o que Cursor sabe. Cursor não sabe o que ChatGPT sabe. Suas decisões de projeto, preferências, arquitetura e contexto de fluxo de trabalho são repetidos em cada ferramenta e em cada nova conversa.

Isso gera trabalho desnecessário:

Reexplicar as mesmas informações
Buscar em repositórios, documentos e conversas
Corrigir respostas com base em contexto ausente
Repetir decisões técnicas e de produto
Começar cada tarefa de IA do zero

Memxus resolve isso por meio da Engenharia de Contexto.

Salve o que importa uma única vez, encontre em segundos e dê a cada IA o contexto exato de que ela precisa para a tarefa.

O resultado é menos repetição, menos idas e vindas, execução mais rápida e respostas melhores em todo o seu fluxo de trabalho com IA.

Salve uma decisão no Claude → recupere-a no Cursor → reutilize-a no ChatGPT.
Precisa de contexto mais profundo? Conecte GitHub e Notion quando estiver pronto.

O que é o Memxus?

Memxus é uma Engenharia de Contexto projetada para multiplicar sua produtividade dando a cada IA o contexto certo.

Ele cria uma camada de contexto compartilhada entre Claude, Cursor, ChatGPT, Gemini e qualquer cliente compatível com MCP.

O fluxo de trabalho principal é simples:

remember o que importa
recall a partir de qualquer IA
encontre contexto relevante em segundos
dê a cada IA as informações de que precisa para produzir uma resposta melhor

Conecte-se uma vez com OAuth e suas decisões, preferências e contexto de trabalho se tornam portáteis em todo o seu fluxo de trabalho com IA — sem configuração local, explicações repetidas ou copiar e colar entre ferramentas.

Para contexto mais profundo, o Memxus também pode se conectar a fontes reais de trabalho, como GitHub e Notion. Repositórios, documentação, commits, pull requests, issues e páginas selecionadas do workspace se tornam pesquisáveis junto com seu contexto salvo manualmente.

Os conectores de GitHub e Notion estão ativos em produção. Essa sincronização mais profunda é opcional: o Memxus entrega valor desde a primeira decisão salva.

Salve uma vez. Encontre rápido. Dê a cada IA o contexto certo. Trabalhe mais rápido.

Por que desenvolvedores usam o Memxus

Salve uma vez, recupere em toda IA — pare de repetir sua stack, decisões e preferências entre Claude, Cursor e ChatGPT
Pergunte uma vez — chega de procurar em 5 ferramentas para lembrar por que você escolheu X
Mantenha a arquitetura do projeto e o contexto da stack disponíveis entre Claude, Cursor e ChatGPT
Sincronize GitHub e Notion em coleções unificadas de projeto — um contexto por repositório
Pare de colar o mesmo contexto em cada nova sessão de IA
Compartilhe contexto de equipe entre agentes e fluxos de trabalho
Crie aplicativos de IA com contexto persistente via MCP ou API

Contexto real do GitHub e Notion

O Memxus lê seu trabalho real — não trechos genéricos de memória. O conteúdo sincronizado vai para uma coleção unificada por projeto: project:<slug>.

O que é sincronizado

Fonte	Conteúdo indexado no contexto
GitHub	Repositórios, READMEs, commits, pull requests, issues
Notion	Páginas e documentos selecionados do workspace
Manual	Decisões, preferências e notas via `remember`

Como conectar

Dashboard — dashboard.memxus.com/integrations (GitHub App + Notion OAuth)
Pelo chat (MCP) — connect_source → check_connect_status → list_syncable_items → set_sync_selection

Como usar o contexto sincronizado

Chame recall ou get_context com collection=project:<slug> (ou deixe a busca semântica encontrar). O conteúdo do GitHub/Notion é marcado e pesquisável junto com as memórias manuais.

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

Comece a salvar em uma mensagem

Depois de conectar o Memxus a qualquer IA, cole uma linha como esta — o Memxus chama remember e seu contexto fica disponível em todos os lugares:

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

Nenhuma sincronização com GitHub/Notion é necessária para começar. Sincronize depois quando quiser um contexto de projeto mais profundo.

Opcional — sincronize toda a sua stack: repositórios do GitHub, páginas do Notion, arquivos, documentos e decisões também se tornam contexto recuperável.

Ferramentas de conector do Context Engine (4): conecte GitHub/Notion pelo chat via MCP. A produção anuncia as 9 ferramentas principais; as 4 ferramentas de conector são habilitadas por conta, então um cliente recém-conectado vê as 9 principais.

Conecte em 1 segundo, um clique

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"
      }
    }
  }
}

Ou abra diretamente no 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 do marketplace: veja REVIEWER.md para configuração de OAuth e Bearer token.

Plataformas suportadas

Plataforma	Integração	Status
Claude Desktop / claude.ai	MCP remoto	✅ Ativo
Cursor	MCP remoto	✅ Ativo
VS Code / Copilot MCP	MCP remoto	✅ Ativo
ChatGPT	Custom GPT / API	✅ Ativo
Gemini	Fluxo de trabalho compatível com MCP	✅ Ativo
Telegram	Conector de bot	✅ Ativo
GitHub	Sincronização de repositório (commits, PRs, issues, README)	✅ Ativo
Notion	Sincronização de páginas do workspace	✅ Ativo
Discord	Conector de bot	🔜 Em breve
Slack	Conector de bot	🔜 Em breve
Qualquer cliente compatível com MCP	MCP remoto	✅ Ativo

Ferramentas disponíveis

Registry com.memxus/memxus v1.2.1 — 9 ferramentas principais sempre disponíveis, além de 4 ferramentas de conector para sincronização de GitHub/Notion pelo chat.

Ferramentas principais (9)

Ferramenta	Descrição
`remember`	Salvar contexto — entrada manual, decisões ou notas; coleção `project:<slug>` opcional
`recall`	Busca semântica em memórias; conteúdo sincronizado do GitHub/Notion via `project:<slug>` ou tags
`get_context`	Bloco de contexto formatado do GitHub, Notion e decisões salvas para prompts de agentes
`list_memories`	Navegue pelas memórias por coleção, tags, tipo ou visibilidade
`get_memory`	Recupere conteúdo completo e metadados pelo ID da memória
`list_collections`	Listar escopos; sincronizações do GitHub/Notion aparecem em `project:<slug>`
`forget`	Excluir uma memória permanentemente
`memory_stats`	Estatísticas por tipo e coleção
`update`	Aplicar patch ou anexar conteúdo, tags ou tipo de memória existente

Ferramentas de conector do Context Engine (4) — v1.2.1

Ferramenta	Descrição
`connect_source`	Iniciar instalação do GitHub App ou OAuth do Notion pelo chat
`list_syncable_items`	Listar repositórios ou páginas do Notion disponíveis após conectar
`set_sync_selection`	Escolher o que sincronizar e acionar a sincronização inicial em `project:<slug>`
`check_connect_status`	Verificar o status da conexão após `connect_source`

Referência completa das ferramentas: memxus.com/docs/mcp · Revisores do marketplace: REVIEWER.md

Arquitetura

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)

A sincronização é executada no servidor via dashboard ou ferramentas de conector MCP — sem arquivos locais para gerenciar.

Transporte: Streamable HTTP (MCP 2.0)
Autenticação: OAuth 2.1 + PKCE + Dynamic Client Registration (RFC 9728)

Segurança

OAuth 2.1 + PKCE — sem senhas, sem chaves de API para gerenciar
Criptografado em repouso (AES-256)
Memória controlada pelo usuário — visualize, edite e exclua a qualquer momento pelo dashboard
Sem arquivos locais ou sincronização manual
Auditoria de segredos pré-publicação aprovada: 2026-06-17
A memória é contexto consultivo, não autoridade de instrução — veja TRUST-POLICY.md para saber o que é lido automaticamente, o que exige uma gravação explícita e o que a camada de memória nunca faz.

Fluxo 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_*

O Dynamic Client Registration é suportado — os clientes se registram automaticamente na primeira conexão.

Self-hosting

Pré-requisitos

Node 20+
Projeto Supabase (execute supabase/migration.sql após a migração do dashboard)
Conta Railway (ou qualquer host Node)

Variáveis de ambiente

cp .env.example .env

Variável	Descrição
`MCP_PUBLIC_URL`	URL pública deste servidor (sem barra final)
`DASHBOARD_URL`	URL do Dash-AIMemory para redirecionamento de login
`SUPABASE_URL`	URL do projeto Supabase
`SUPABASE_SERVICE_ROLE_KEY`	Chave de função de serviço do Supabase
`OAUTH_CLIENT_ID`	ID do cliente OAuth
`ALLOWED_REDIRECT_URIS`	URIs de redirecionamento permitidas separadas por vírgula
`CORS_ORIGINS`	Origens CORS permitidas separadas por vírgula
`OPENAI_API_KEY`	(Opcional) Embeddings de busca vetorial

Executar localmente

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

Implantar no Railway

Defina todas as variáveis em Settings → Variables (nunca faça commit de .env).
MCP_PUBLIC_URL = sua URL de rede do Railway (sem /mcp final).
Endpoint de health check: /health (configurado em [railway.toml](railway.toml)).

Nota: Node 20 no Railway — o Supabase Realtime precisa do pacote ws (configurado em src/lib/supabase.ts).
Opcional: defina RAILPACK_NODE_VERSION=22 para suporte nativo a WebSocket.

Desenvolvimento

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 do marketplace: REVIEWER.md · Documentação MCP: memxus.com/docs/mcp · Registry: com.memxus/memxus v1.2.1

Releases

Adicione entradas em ## [Unreleased] em [CHANGELOG.md](CHANGELOG.md)
Atualize a versão em package.json, server.json, src/mcp/server.ts e src/mcp/public-discovery.ts
Mova a seção de changelog para ## [X.Y.Z] - YYYY-MM-DD
Faça commit, tag e push:

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

Enviar uma tag v* aciona [.github/workflows/release.yml](.github/workflows/release.yml) — quality gate + GitHub Release com server.json anexado.

Auditoria de segredos

Execute a partir da raiz do repositório antes de tornar o repositório público.
Última auditoria: 2026-06-17 — APROVADO

# 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

Verificação	Esperado
Comandos 1–2	Sem commits `.env` (apenas `.env.example` no commit inicial)
Comando 3	Apenas placeholders (`aimem_YOUR_KEY`), fixtures de teste, comentários SQL
Comando 4	Sem valores reais de chaves em diffs

Se os comandos 1 ou 4 encontrarem segredos reais, rotacione as chaves imediatamente e execute git filter-repo --path .env --invert-paths antes de publicar.

Roadmap

Licença

Licenciado sob a GNU Affero General Public License v3.0 (AGPL-3.0).

Você pode usar, modificar e distribuir este código livremente. Se usá-lo para executar um serviço de rede (SaaS), você deve publicar seu código-fonte sob a mesma licença.

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