Aplicativos de IA com benchmark de memória MCP e tutorial
Testamos quatro servidores de memória do Protocolo de Contexto de Modelo (MCP) para avaliar quais deles realmente retêm e recuperam o contexto entre sessões de agentes de IA. Usando o ReAct Agent da LangChain, conectamos cada servidor, executamos conversas padronizadas em múltiplas sessões e os avaliamos quanto à precisão das operações de memória.
Também criamos uma demonstração funcional que conecta Claude e Cursor por meio do OpenMemory MCP, uma camada de memória compartilhada que mantém o contexto entre as duas ferramentas. A demonstração mostra como a memória funciona na prática: o que é armazenado, quando é recuperado e como o contexto determina quais informações são exibidas .
Resultados e metodologia do teste de desempenho do servidor de memória MCP
Avaliamos a capacidade de grandes modelos de linguagem (LLMs) gerenciarem o conhecimento em conversas com múltiplas sessões, preservarem o contexto conversacional e recuperarem informações importantes utilizando sistemas de memória externa. Avaliamos quatro implementações distintas de servidores MCP: Handrails 1 , Grafo de Conhecimento 2 , Memória Básica 3 e Zine 4 .
O objetivo do nosso teste de desempenho é medir a capacidade de um servidor MCP para:
- Recordar o conteúdo com precisão durante os intervalos da sessão, sem repetir as mesmas perguntas.
- Execute as operações de memória adequadas (leitura, escrita, atualização e exclusão) nos momentos apropriados.
- Modifique as respostas levando em consideração o contexto do usuário e os dados de preferências previamente salvos.
Exemplos de interações em MCP a partir do conjunto de dados
1- Problema na instalação de pacotes: Este exemplo testa como o sistema lida com uma situação em que um usuário tenta instalar um software e encontra problemas. Segue uma descrição da interação:
- Sessão 1: "Estou com dificuldades para instalar o pacote 25."
- Sessão 2: "Tentei instalar o apt, mas recebi uma mensagem de permissão negada."
- Sessão 2 (continuação): “Funcionou! Obrigado!” (após a sugestão do sudo)
Comportamento esperado: O sistema deve registrar que o comando sudo resolveu o problema de instalação para casos semelhantes no futuro.
2- Teste de adaptação da habilidade do usuário: Este exemplo se concentra em como o sistema adapta suas respostas com base no nível de experiência do usuário. Aqui está uma descrição da interação:
- Sessão 1: “Preciso de ajuda com meu pedido de benefícios. Sou iniciante nisso.”
- Intervalo da sessão
- Sessão 2: "Obrigado, mas não consigo entrar agora."
Comportamento esperado: O agente deve lembrar que o usuário é um iniciante e fornecer explicações mais simples em vez de etapas avançadas de solução de problemas.
Operações de memória
Cada diálogo envolve operações de memória específicas que o servidor executa, testando sua capacidade de armazenar/escrever , recuperar/ler , atualizar e limpar a memória.
- Escreva: Salve as informações iniciais do dispositivo, os sintomas e o nível de habilidade do usuário.
- Leia: Recuperar o contexto anterior quando as sessões forem retomadas.
- Atualização: Acompanhe os resultados da solução (sucesso ou fracasso).
- Excluir: Remover informações desatualizadas.
Como funciona o benchmark
Nosso benchmark utiliza o framework de agentes ReAct da LangChain e o modelo base OpenAI. Testamos cada servidor MCP (Knowledge Graph, Basic Memory, Handrail, Zine) individualmente.
Cada cenário é executado para verificar a persistência de memória do sistema e o gerenciamento de diálogos em múltiplas sessões. Testamos a memória do sistema da seguinte forma:
- Validação e carregamento de conjuntos de dados: Carrega conversas de múltiplas sessões em formato JSON e verifica a estrutura principal.
- Inicialização do agente:
- Conecta o servidor MCP a um agente ReAct e configura um prompt de sistema específico para operações de memória no agente.
- Utiliza uma lista de permissões de ferramentas para restringir as operações às funções de memória relevantes.
- Processamento por turnos : Mantém o histórico da conversa, gerenciando cada sessão separadamente e indicando claramente as pausas na sessão para avaliar a continuidade.
- Execução de operações de memória:
- Implementa medidas de segurança que seguem as melhores práticas, como a prevenção de duplicatas, exigindo verificação antes da gravação e garantindo que a memória seja lida após o término da sessão.
- Oferece oportunidades para novas tentativas quando as salvaguardas são ativadas.
- Análise de chamadas de ferramentas:
- Todas as chamadas de ferramentas são extraídas e categorizadas (leitura, gravação, atualização, exclusão).
- Analisa as tendências de sequência de ferramentas ao longo dos limites das sessões e dentro dos turnos.
- Monitora as mudanças entre vários tipos de operação, como gravação-atualização e leitura-gravação.
- Avaliação e pontuação:
- Compara as operações esperadas a partir das anotações do conjunto de dados com as operações observadas.
- Determina a precisão de cada interação e combina métricas de várias conversas.
- Mede, em particular, os comportamentos de leitura no currículo e leitura antes da escrita.
- Análise de erros: Registra relatórios detalhados de cada turno com informações operacionais, classifica erros, rastreia tendências de falhas e produz relatórios e resumos de desempenho.
- Saída: Gera arquivos CSV com dados de referência e relatórios resumidos com métricas-chave, facilitando a leitura das informações.
Nossa principal métrica é a precisão operacional , que mede a porcentagem de iterações em que o modelo executa as operações de memória esperadas.
O problema da falta de memória compartilhada entre as ferramentas
É comum usar ferramentas como o Claude para gerar ideias. Normalmente, eu pego esse plano e alterno entre diferentes ferramentas. No entanto, sem memória compartilhada, diferentes ferramentas de IA não se lembram de decisões passadas, escolhas arquitetônicas anteriores ou das nuances do seu código.
Isso levanta vários problemas:
- O contexto se perde entre as ferramentas: quando você faz alterações em uma ferramenta, como atualizar um plano ou ajustar a pilha de tecnologias no Claude , o Cursor não reconhece essas alterações ao retornar para ele. Você precisa inserir todos os detalhes manualmente. Por exemplo, cada vez que você volta ao projeto, precisa explicar novamente coisas como o framework que está usando (por exemplo, React com Redux ou Flutter com Bloc).
- Duplicação de dados: Você também precisa repetir informações em diferentes ferramentas. Por exemplo, a pilha de tecnologias, o layout e os recursos do aplicativo precisam ser redefinidos no Cursor , mesmo que já estejam definidos no Claude .
- Produtividade reduzida: Como as ferramentas não compartilham memória, você acaba constantemente reintroduzindo o mesmo contexto.
Como a memória e o MCP funcionam em conjunto?
No sistema Memory MCP , todas as suas ferramentas de IA e clientes MCP (como o Cursor) funcionam em conjunto, aproveitando tanto a memória quanto o Protocolo de Contexto de Modelo (MCP) .
- A memória armazena informações personalizadas e persistentes sobre as preferências do usuário e tarefas recorrentes. Por exemplo, o Cursor memoriza suas linguagens de programação preferidas, tom de voz e detalhes do fluxo de trabalho.
- O MCP fornece acesso em tempo real a dados dinâmicos e específicos da tarefa, como arquivos de projeto ou APIs, durante uma sessão. Ele garante que informações atualizadas e específicas do contexto sejam recuperadas quando necessário.
Introdução ao OpenMemory
O OpenMemory é uma ferramenta da MemZero que oferece um sistema de memória unificado para diversos aplicativos e agentes de IA. Imagine-o como um "chip de memória" que integra todos os seus clientes MCP em um único espaço de memória contínuo. Ele pode ser usado localmente ou na nuvem.
Tutorial: OpenMemory MCP
Requisitos
Antes de começarmos, certifique-se de que você tem o seguinte configurado:
- Docker : Necessário para executar os servidores OpenMemory e MCP localmente ( instale o Docker ).
- Git : Para clonar os repositórios necessários.
- OpenMemory: Você precisará instalaro OpenMemory para interagir com os servidores LLM localmente.
- Chave de API : Você precisará da sua chave de API para interações com o LLM. Neste exemplo, usaremos a chave de API OpenAI .
Configurando o OpenMemory
Nota de segurança: Ao configurar e usar o OpenMemory, recomenda-se não compartilhar chaves de API privadas, senhas ou qualquer outra informação sensível diretamente em seu código ou repositórios públicos.
Passo 1: Clone o repositório
A pasta do OpenMemory no GitHub está localizada dentro da pasta `mem`, pois `mem` é o repositório principal. Para obter o OpenMemory, precisamos clonar todo o repositório `mem`.
1. Acesse o repositório MemZero e copie o link do repositório (https://github.com/mem0ai/mem0.git).
2. Abra seu terminal e digite git clone seguido pelo link do repositório do GitHub.
3. Navegue até o diretório : Após clonar o sistema, acesse a pasta mem0 (digite cd mem0) e localize a pasta OpenMemory (digite cd openmemory/). Em seguida, navegue até essa pasta e todos os comandos subsequentes serão executados a partir dela.
Para executar o OpenMemory, você precisa executar tanto a interface do usuário quanto o servidor MCP.
Portanto, você precisa instalar o Docker para conteinerizá-los. Com o Docker, tanto a interface do usuário quanto o servidor MCP podem ser empacotados com todas as suas dependências em contêineres, garantindo uma execução consistente em diferentes ambientes.
Isso permite configurar, executar e dimensionar a interface do usuário e o servidor MCP sem se preocupar com a configuração manual.
Etapa 2: Configurar o Docker e criar contêineres
Se o Docker não estiver instalado em seu sistema, faça o download e instale-o a partir do site do Docker .
Crie os contêineres Docker : Execute o seguinte comando “make build” para criar os contêineres, o que instalará as dependências necessárias:
Inicie os contêineres : Depois que os contêineres forem criados, inicie-os digitando “make up”.
Você só precisa executar o comando `make build` uma vez. Depois disso, basta executar `make up` para iniciar os contêineres quando necessário.
Além disso, para usar o servidor MCP, o Docker precisa estar em execução no seu sistema. Até que você tenha acesso à nuvem, será necessário manter o Docker ativo para executá-lo localmente.
Se você acessar a aba "Make", poderá ver que o servidor OpenMemory MCP já está em execução :
O servidor OpenMemory MCP deve estar em execução em: http://localhost:8765 por padrão.
Etapa 3: Configurar o servidor MCP
Agora que o Docker está em execução, o próximo passo é configurar o servidor MCP para gerenciar a camada de memória.
A interface do usuário do OpenMemory é executada em http://localhost:3000 por padrão. Com o Docker em execução, o servidor MCP estará ativo e acessível localmente neste endereço. Para garantir que o servidor esteja funcionando corretamente, basta acessar http://localhost:3000 no painel do OpenMemory.
Passo 4: Configurar clientes (Claude/Cursor neste exemplo)
Para conectar Claude e Cursor (ou qualquer outro agente) ao sistema de memória compartilhada, abra o diretório no Cursor e digite `cursor` no seu terminal:
Configure a chave de API OpenAI : Abra a pasta API na estrutura do projeto. Depois de aberta, ela terá uma aparência semelhante a esta, e a estrutura de arquivos será assim:
Dentro da estrutura de arquivos, acesse a pasta API . Lá, você encontrará um arquivo av_example .
Você precisa colar sua chave de API OpenAI neste arquivo. Copie-o, renomeie-o para .env removendo a palavra "example" do nome do arquivo e, em seguida, cole sua chave de API real nele.
Assim que isso for concluído, você poderá usar o comando de maquiagem . Eles listaram essa etapa como um pré-requisito porque ela é necessária para as interações do LLM, e é por isso que solicitam a chave Open API.
Etapa 5: Configurar o MCP nas ferramentas
Precisamos instalar o MCP para diferentes ferramentas. Temos o link do MCP, que você precisa configurar manualmente nas configurações. Ao executá-lo, o MCP será adicionado automaticamente ao cliente Claude. O mesmo se aplica ao Cursor.
Como podem ver, instalei ambos os MCPs. Aqui estão instalados o Claude e o Cursor :
Você pode ver que no Cursor ele já está funcionando :
Exemplo de implementação de MCP
Este exemplo mostra como usar o servidor MCP. Você pode abrir o Claude Desktop e pedir que ele faça um brainstorming de ideias para diferentes tipos de aplicativos ou soluções. Neste exemplo, vamos explorar como gerar um conceito para um aplicativo de controle de tempo.
Primeiramente, Claude apresenta seu próprio plano. Você pode dar continuidade ao assunto com os pontos listados abaixo, focando nos recursos que devem ser implementados.
Depois de incorporar as alterações ao plano original, você pode solicitar que ele salve o plano na memória como "plano de controle temporal".
Você pode visualizar os detalhes da memória na aba à direita do painel do OpenMemory. Aqui estão os detalhes da memória:
Passando para o Cursor, você pode dar um comando como "Quero criar um aplicativo de controle de tempo" e perguntar se ele consegue recuperar os detalhes da memória.
Em seguida, utilizou as ferramentas MCP para listar e pesquisar a memória. Esse recurso é incrivelmente útil, pois permite buscar informações relevantes. Por exemplo, ao consultar o aplicativo de controle de tempo, recuperou todas as memórias relacionadas a esse tópico.
A partir daí, extraiu detalhes sobre Next.js, React, TypeScript e o restante da pilha tecnológica a ser usada. Em seguida, começou a construir o aplicativo.
Após concluir a tarefa, você pode solicitar que o progresso seja salvo na memória, e ele o fará. Isso inclui adicionar notas de progresso, dividir tudo em partes gerenciáveis e armazená-las também. Assim, todas as atualizações ficam salvas na memória.
Aqui está o aplicativo criado:
Desafios após a criação do aplicativo
Após algum tempo, o Cursor apresentou um erro ao iniciar um novo chat devido ao tamanho do contexto. Assim que um novo chat é iniciado, é possível solicitar a recuperação de dados relacionados ao progresso do aplicativo. Ele então chamou a ferramenta MCP novamente e recuperou todos os dados relevantes, como a localização em que estava sendo executado e o que havia sido feito até então.
Em seguida, foi fornecida uma captura de tela porque o contraste em alguns elementos React estava ruim e o texto não estava visível. Você pode pedir para corrigir a interface do usuário, o que foi feito.
Enquanto trabalhava nisso, o programa chamava a si mesmo repetidamente, tentando localizar o diretório de origem. No entanto, ele não identificou a existência de uma pasta "front-end".
Como o MCP, o Cursor e o Claude recuperavam e gerenciavam a memória.
Agora, o que você quer ver é como ele realmente recupera as memórias.
O mais importante é notar que essa memória está vinculada a todas as outras memórias criadas na mesma sessão. Portanto, se o cliente MCP solicitar uma memória com o rótulo "tempo", ele também buscará as memórias relacionadas.
Você pode verificar o aplicativo de origem de cada memória. Algumas foram criadas por Cursor, outras por Claude. Ao abrir a memória, você pode visualizar o registro de acesso, alterar o status ou até mesmo editar a própria memória.
Testando a capacidade do MCP de diferenciar entre projetos
Para testar se o sistema MCP consegue diferenciar entre projetos diferentes, altere a pilha tecnológica para a pilha MERN e instrua o Claude Desktop a enviar essas novas informações para o servidor MCP.
Em seguida, abra o Cursor e consulte qual conjunto de tecnologias será usado para o novo projeto. Certifique-se de selecionar apenas o MCP e evite verificar o diretório do projeto para obter contexto adicional.
Resultados dos testes:
Quando a chamada MCP é feita, o sistema fica confuso, puxando as duas pilhas de tecnologia, a pilha MERN do projeto anterior e o Next.js do novo, recuperando-as simultaneamente.
Isso demonstra como o sistema MCP não conseguiu separar os contextos dos dois projetos.
Assim, embora o sistema MCP possa armazenar dados em diferentes sessões, ocasionalmente pode misturar informações de projetos diferentes.
Considerações finais
Embora o sistema MCP seja um bom começo, ele precisa de uma melhor separação de memória para projetos semelhantes, a fim de evitar sobreposição de dados. Ele funciona bem para projetos individuais ou com nomes distintos, mas melhorias na execução de consultas e no gerenciamento de memória o tornariam ainda mais poderoso.
Quais são as outras aplicações do Memory MCP?
1. Assistente de pesquisa multiagente com uma camada de memória
Vários agentes LLM se especializam em diferentes domínios de pesquisa (por exemplo, artigos acadêmicos, repositórios do GitHub, notícias). Cada agente armazena suas descobertas na memória, que o agente mestre pode consultar posteriormente para obter contexto relacionado.
Exemplo da vida real : Anthropic Sistema de Pesquisa Multiagente. 7
2. Assistente de reuniões com memória persistente entre sessões
Um assistente armazena resumos de reuniões, itens de ação e anotações principais, recuperando o contexto relevante para reuniões futuras.
Exemplo prático : Otter.ai é um assistente de reuniões que captura pontos-chave e os recupera em sessões futuras para manter o contexto. Para saber mais sobre o Otter.ai, consulte: Anotador de IA
3. Assistente de codificação agético que evolui com o uso
Assistentes de programação que aprendem com padrões de uso e armazenam soluções para problemas recorrentes, recuperando e aplicando automaticamente soluções anteriores para aumentar a produtividade.
Exemplo prático : GitHub Copilot, um assistente de programação que aprende com o estilo de código do desenvolvedor. Para mais informações sobre agentes cognitivos, consulte: Memória de agentes de IA .
Links de referência
Seja o primeiro a comentar
Seu endereço de e-mail não será publicado. Todos os campos são obrigatórios.