Memstate AI MCP Server

Memstate AI - MCP

Memória versionada para agentes de IA. Armazene fatos, detecte conflitos e acompanhe como as decisões mudam ao longo do tempo — exposto como um servidor MCP hospedado.

Dashboard · Docs · Preços

---

Por que Memstate?

	RAG (maioria dos outros sistemas de memória)	Memstate AI
Uso de tokens por conversa	~7.500	~1.500
Visibilidade do agente	Caixa preta	Transparência total
Versionamento de memória	Nenhum	Histórico completo
Crescimento de tokens conforme as memórias escalam	O(n)	O(1)
Infraestrutura necessária	Sim	Nenhuma — SaaS hospedado

Outros sistemas de memória despejam tudo na sua janela de contexto e torcem pelo melhor. O Memstate fornece ao seu agente uma base de conhecimento estruturada e versionada que ele navega com precisão — carregue apenas o que precisa, saiba o que mudou, saiba quando os fatos entram em conflito.

---

Benchmarks

Construímos uma suíte de benchmark de código aberto que testa o que realmente importa para a memória do agente: seu sistema pode armazenar fatos, recuperá-los com precisão entre sessões, detectar conflitos quando as coisas mudam e manter o contexto à medida que um projeto evolui?

Comparativo Direto: Memstate AI vs Mem0

Ambos os sistemas foram testados em condições idênticas usando o mesmo agente (Claude Sonnet 4.6, temperatura 0), os mesmos cenários e a mesma rubrica de pontuação.

Métrica	Memstate AI	Mem0	Vencedor
Pontuação Geral	69,1	15,4	Memstate
Precisão (recuperação de fatos)	74,1	12,6	Memstate
Detecção de Conflitos	85,5	19,0	Memstate
Continuidade de Contexto	63,7	10,1	Memstate
Eficiência de Tokens	22,3	30,6	Mem0

Pesos da pontuação: Precisão 40%, Detecção de Conflitos 25%, Continuidade de Contexto 25%, Eficiência de Tokens 10%.

Detalhamento por Cenário

O benchmark executa cinco cenários do mundo real que simulam fluxos de trabalho de agente em várias sessões:

Cenário	Memstate AI	Mem0
Evolução da Arquitetura de Aplicação Web	43,2	55,6
Migração de Sistema de Autenticação	66,2	10,2
Evolução do Esquema de Banco de Dados	72,7	7,0
Conflitos de Versionamento de API	86,5	0,9
Reversão de Decisão da Equipe	77,2	3,3

O Mem0 venceu o primeiro cenário (rastreamento simples de arquitetura), mas teve dificuldades severas em cenários que exigiam tratamento de contradições, contexto entre sessões e rastreamento de reversão de decisões — pontuando próximo de zero em três dos cinco cenários.

Por que o Memstate Vence

O benchmark revela uma diferença arquitetural fundamental:

O Mem0 usa busca semântica baseada em embeddings. Os fatos são divididos em chunks, transformados em embeddings e recuperados por similaridade. Isso funciona para consultas simples, mas falha quando:

• Fatos contradizem fatos anteriores (o sistema não consegue distinguir entre atual e desatualizado)
• É necessária uma recuperação precisa (embeddings retornam resultados "semelhantes", não exatos)
• A latência de escrita para leitura importa (novas memórias levam segundos para se tornarem pesquisáveis)

O Memstate usa armazenamento estruturado e versionado de chave-valor. Cada fato reside em um keypath explícito com um histórico completo de versões. Isso significa:

• A detecção de conflitos é integrada — quando um novo fato contradiz um antigo, o sistema sabe e preserva ambas as versões
• A recuperação é determinística — você recebe exatamente o que foi armazenado, não uma correspondência aproximada
• A continuidade entre sessões é confiável — o agente navega por uma árvore estruturada em vez de torcer para que a busca semântica traga o contexto certo
• O custo de tokens permanece O(1) — o agente carrega resumos primeiro e se aprofunda nos detalhes apenas quando necessário, em vez de despejar todos os embeddings potencialmente relevantes na janela de contexto

Notas de Imparcialidade

• Ambos os sistemas usaram o mesmo modelo de agente, temperatura e rubrica de avaliação
• Foi dado ao Mem0 um atraso de ingestão de 10 segundos entre escritas e leituras para contabilizar seu pipeline de embedding assíncrono
• O Mem0 pontua mais alto em eficiência de tokens, mas essa métrica deve ser lida em contexto — menor uso de tokens pode simplesmente refletir que menos informação está sendo retornada. Um sistema que recupera fatos incompletos ou incorretos usa menos tokens por resposta, mas pode exigir mais chamadas de acompanhamento, custando, em última análise, mais tokens para chegar à mesma resposta
• O código-fonte do benchmark está incluído neste repositório para total reprodutibilidade
• O Mem0 pode ter desempenho diferente com configuração personalizada ou um modelo de embedding diferente

---

Início Rápido

Obtenha sua chave de API em memstate.ai/dashboard e adicione à configuração do seu cliente MCP:

{
  "mcpServers": {
    "memstate": {
      "command": "npx",
      "args": ["-y", "@memstate/mcp"],
      "env": {
        "MEMSTATE_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}

Sem Docker. Sem banco de dados. Sem infraestrutura. Funcionando em 60 segundos.

---

Configuração do Cliente

Claude Desktop

Local da configuração:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "memstate": {
      "command": "npx",
      "args": ["-y", "@memstate/mcp"],
      "env": { "MEMSTATE_API_KEY": "YOUR_API_KEY_HERE" }
    }
  }
}

Claude Code

claude mcp add memstate npx @memstate/mcp -e MEMSTATE_API_KEY=YOUR_API_KEY_HERE

Cursor

Em Configurações do Cursor → MCP → Adicionar Servidor — mesmo formato JSON do Claude Desktop acima.

Cline / Windsurf / Kilo Code / Roo Code

Todos suportam o mesmo formato de configuração MCP stdio. Adicione ao arquivo de configurações MCP do seu cliente.

---

Ferramentas Principais

Ferramenta	Quando usar
memstate_remember	Armazenar markdown, resumos de tarefas, decisões. O servidor extrai keypaths e detecta conflitos automaticamente. Use para a maioria das escritas.
memstate_set	Definir um único keypath para um valor curto (ex.: config.port = 8080). Não para prosa.
memstate_get	Navegar por todas as memórias de um projeto ou subárvore. Use no início de cada tarefa.
memstate_search	Busca semântica por significado quando você não sabe o keypath exato.
memstate_history	Veja como um conhecimento mudou ao longo do tempo — cadeia de versões completa.
memstate_delete	Excluir logicamente um keypath. Cria um tombstone; o histórico completo é preservado.
memstate_delete_project	Excluir logicamente um projeto inteiro e todas as suas memórias.

Como os keypaths funcionam

As memórias são organizadas em notação de ponto hierárquica:

project.my_app.database.schema
project.my_app.auth.provider
project.my_app.deploy.environment

Keypaths são prefixados automaticamente: keypath="database" com project_id="my_app" → project.my_app.database. Seu agente pode se aprofundar exatamente no que precisa — sem despejos de contexto completo.

---

Como Funciona

Agent: memstate_remember(project_id="my_app", content="## Auth\nUsing SuperTokens...")
         ↓
Server extracts keypaths:  [project.my_app.auth.provider, ...]
         ↓
Conflict detection:  compare against existing memories at those keypaths
         ↓
New version stored — old version preserved in history chain
         ↓
Next session: memstate_get(project_id="my_app") → structured summaries only
         ↓
Agent drills into project.my_app.auth only when it needs auth details

O custo de tokens permanece constante, independentemente de quantas memórias totais existam.

---

Adicione às Instruções do Seu Agente

Copie para o seu AGENTS.md ou prompt do sistema:

## Memory (Memstate MCP)

### Before each task
- memstate_get(project_id="my_project") — browse existing knowledge
- memstate_search(query="topic", project_id="my_project") — find by meaning

### After each task
- memstate_remember(project_id="my_project", content="## Summary\n- ...", source="agent")

### Tool guide
- memstate_remember — markdown summaries, decisions, task results (preferred)
- memstate_set — single short values only (config flags, status)
- memstate_get — browse/retrieve before tasks
- memstate_search — semantic lookup when keypath unknown
- memstate_history — audit how knowledge evolved
- memstate_delete — remove outdated memories (history preserved)

---

Variáveis de Ambiente

Variável	Padrão	Descrição
MEMSTATE_API_KEY	(obrigatório)	Chave de API de memstate.ai/dashboard
MEMSTATE_MCP_URL	https://mcp.memstate.ai	Substituir para implantações auto-hospedadas

Verifique Sua Conexão

MEMSTATE_API_KEY=your_key npx @memstate/mcp --test

Exibe todas as ferramentas disponíveis e confirma se sua chave de API funciona.

Construído para agentes de IA que merecem saber o que sabem.