Mnemo com Ollama: memória local, implantação e controle

Seu modelo no Ollama já responde perguntas, mas cada conversa ainda começa do zero. A decisão de projeto discutida ontem, a preferência definida hoje e a restrição que você vai precisar amanhã desaparecem.

Esse é o problema de memória nos LLMs locais. O Ollama oferece um serviço de modelo capaz de responder. O que ele responde, e se lembra das restrições anteriores, depende do quanto você repete manualmente em cada prompt.

Mnemo não está refazendo RAG. Ele usa grafo de conhecimento e extração de entidades para gerenciar memória de longo prazo, permitindo que seu LLM local lembre decisões de projeto e relações entre entidades, em vez de perguntar de novo: “para que serve esta API?“

1. O que é Mnemo: posicionamento e capacidades principais

1.1 Lendo o posicionamento

Em “local-first AI memory layer”, duas partes importam:

• local-first: os dados ficam na sua máquina, não sobem para a nuvem, podem ser migrados e não dependem da vida de um SaaS
• memory layer: não é outro RAG nem outro framework de agente. Ele cuida da memória em si: extração de entidades, construção de grafo e recuperação semântica

Por exemplo: você pergunta “qual é a URL base da API deste projeto?”. Uma busca vetorial pura pode devolver vários trechos relacionados a “API”, mas não sabe de qual projeto você está falando. A recuperação por grafo pode seguir a cadeia “projeto -> API -> baseUrl” e devolver o valor configurado antes.

Isso só funciona se a extração de entidades estiver correta. Se o LLM dividir “URL base da API” em duas entidades, “API” e “URL base”, o grafo se fragmenta e a recuperação quebra. É aí que o ruído começa a se acumular.

Com o posicionamento claro, fica mais fácil ler as capacidades.

1.2 Matriz de capacidades principais

O README do Mnemo lista quatro capacidades principais:

1. persistent knowledge graph (grafo de conhecimento persistente)

   • Entidades e relações ficam em SQLite, não em vetores descartáveis
   • A estrutura do grafo pode ser consultada, exportada e migrada

2. entity extraction (extração de entidades)

   • Identifica automaticamente entidades em conversas, como pessoas, projetos, APIs e decisões
   • Não é recuperação vetorial pura. Ele transforma “para que serve esta API?” em uma estrutura entidade-relação consultável
   • A qualidade depende da compreensão do LLM. LLMs locais como llama3 podem identificar entidades de forma errada em conversas complexas, e o ruído se acumula. O README não traz limpeza automática, então é preciso revisar regularmente a qualidade do grafo

3. semantic retrieval (recuperação semântica)

   • Combina busca de texto completo em trechos, busca por nomes de entidades, expansão do grafo, filtro de relações e ranking ponderado
   • Reduz o peso dos resultados expandidos para manter correspondências diretas acima de relações inferidas e limitar o contexto

4. graph-first vs pure vector search

Busca vetorial pura pergunta: “o que é parecido?”. Recuperação por grafo pergunta: “o que está relacionado?”. A primeira pode trazer ruído parecido, mas irrelevante. A segunda segue cadeias de relação entre entidades.

A comparação deixa mais claro:

1.3 Stack técnico e licença

Stack técnico:

Vultr - Servidor cloud NVMe de alto desempenho, 32 locais globais, deploy Docker com um clique

Ver preços →Anúncio

• Rust, dividido em quatro crates descritas na próxima seção
• SQLite para armazenamento local, com modo WAL
• petgraph para o grafo em memória
• API OpenAI, Ollama ou Anthropic como backend LLM

Licença: MIT License. Dá para usar, modificar e redistribuir.

Avisos de risco:

• Projeto em estágio inicial, com base no README do GitHub de 2026-06-05
• APIs e arquitetura podem mudar
• Não há validação ampla em produção documentada
• Os números de desempenho do README são medições próprias, não prova independente

2. Arquitetura: quatro crates em Rust

Mnemo é escrito em Rust e dividido em quatro crates com responsabilidades claras:

mnemo-core: lógica central

• Extração de entidades, construção do grafo e lógica de recuperação
• Não depende de um backend LLM específico; define interfaces

mnemo-api: servidor

• Oferece a API HTTP, por padrão na porta 8080
• Recebe conversas, chama core e devolve resultados
• Health check: curl http://localhost:8080/health

mnemo-cli: ferramenta de linha de comando

• Depuração, gestão e consultas
• Chama a API do Mnemo por HTTP para ingestão, recuperação, inspeção de entidades e limpeza total

mnemo-bench: benchmarks de desempenho

• Os 122 Rust tests, 21 Python tests e 12 benchmarks mencionados no README aparecem aqui
• Fonte das medições próprias

Vantagens de separar em quatro crates:

• core pode ser testado isoladamente, sem depender da API
• cli facilita depuração local sem subir o serviço
• bench fica isolado e não afeta código de produção

Pontos fracos:

• Sem Docker, você precisa da toolchain completa de Rust
• Quando APIs entre crates mudam, várias partes podem precisar de ajuste ao mesmo tempo

3. Instalação e deploy: três caminhos

Mnemo oferece três caminhos de deploy, por ordem de complexidade:

3.1 Docker + Ollama: o jeito mais rápido de começar

Pré-requisitos: Docker e Ollama instalados.

# 1. clonar o projeto
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. iniciar Docker
docker compose up -d

# 3. baixar o modelo dentro do Docker
docker exec mnemo-ollama ollama pull llama3

# 4. health check
curl http://localhost:8080/health

Atenção: os comandos podem mudar. Use o README do GitHub como fonte de verdade.

Explicação: Docker compose sobe dois contêineres: mnemo-api, o servidor, e mnemo-ollama, o serviço Ollama. O segundo é opcional. Se você já tem Ollama rodando localmente, pode usar só o contêiner mnemo-api e conectar com MNEMO_LLM_BASE_URL=http://host.docker.internal:11434/v1.

Validar a conexão LLM: quando o health check devolve {"status":"ok"}, a API está de pé, mas a conexão com o LLM ainda não foi testada. Envie uma requisição com curl:

curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/json" \
  -d '{"content":"O projeto Atlas usa https://api.example.test como URL base","source":"chat","session_id":"mnemo-trial"}'

Depois da escrita, chame /retrieve para validar a recuperação:

curl -X POST http://localhost:8080/retrieve \
  -H "Content-Type: application/json" \
  -d '{"text":"Qual é a URL base da API do Atlas?","session_id":"mnemo-trial"}'

Se a resposta trouxer entidades, trechos de memória ou context_prompt, extração e recuperação funcionam.

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

Vantagens:

• Não precisa de toolchain Rust
• Docker cuida das dependências automaticamente
• Ollama e Mnemo ficam na mesma rede compose, o que simplifica a rede

Desvantagens:

• Docker consome recursos
• Depurar é menos prático, porque é preciso entrar no contêiner para inspecionar SQLite
• Logs ficam espalhados entre dois contêineres

3.2 Binary: compilação local

Pré-requisitos: toolchain Rust instalada, com cargo e rustc, e Ollama instalado.

# 1. clonar o projeto
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. compilar a crate da API
cargo install --path crates/mnemo-api

# 3. configurar o endereço do Ollama
export MNEMO_LLM_BASE_URL=http://localhost:11434/v1

# 4. iniciar o serviço
mnemo-api

Atenção: os comandos podem mudar. Use o README do GitHub como fonte de verdade; este caminho exige toolchain Rust.

Explicação: o tempo de compilação depende do hardware e do cache do Cargo. Depois, mnemo-api usa mnemo.db no diretório atual por padrão. Altere o caminho com MNEMO_DB_PATH ou pela configuração TOML.

Validar a conexão com Ollama: antes de iniciar, confirme que Ollama está em localhost:11434 e que o modelo foi baixado com ollama pull llama3. Depois, teste com curl:

curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/json" \
  -d '{"content":"Testar extração de entidades no Mnemo","source":"cli-check"}'

Vantagens:

• Não depende de Docker
• Mais fácil de depurar, por ser um processo local com logs no mesmo terminal
• mnemo-cli pode operar direto no SQLite local
• Porta e caminho do banco podem ser personalizados por variáveis de ambiente

Desvantagens:

• Exige toolchain Rust completa
• Primeira compilação pode demorar
• Dependências podem dar problema, por exemplo se cargo.lock estiver desatualizado

3.3 OpenAI-compatible: LLM em nuvem

Pré-requisitos: você tem uma API key da OpenAI, Anthropic ou outro backend compatível com OpenAI.

Lista de variáveis de ambiente, verificada no README do GitHub de 2026-06:

export MNEMO_LLM_BASE_URL=https://api.openai.com/v1
export MNEMO_LLM_API_KEY=sk-...
export MNEMO_LLM_MODEL=gpt-4o-mini
export MNEMO_LLM_PROVIDER=openai

Depois, inicie:

mnemo-api

Atenção: nomes de variáveis podem mudar. Use o README do GitHub como fonte de verdade.

Quando faz sentido:

• Sua máquina local não tem poder de cálculo suficiente, então você usa um LLM em nuvem
• Você já tem cota da API da OpenAI
• Você aceita que conteúdo de conversa seja enviado para a API em nuvem. Com LLM cloud, a vantagem local-first vale para armazenamento local, não para o tráfego de inferência

Escolha um dos três caminhos conforme sua realidade. A próxima pergunta é desempenho.

4. Desempenho: medições próprias do README

O README do Mnemo lista medições próprias, verificadas novamente em 17 de julho de 2026:

Condições de teste:

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

• Apple M2, debug build
• SQLite em modo WAL
• petgraph em memória

Números de desempenho:

• Pipeline completo de recuperação: cerca de 4,2 ms
• Release build declara ser 3 a 5 vezes mais rápido, algo como 0,8 a 1,4 ms

Atenção: é uma medição do README, não prova independente. Desempenho varia com hardware, volume de dados e backend LLM.

Como ler esses números:

• 4,2 ms é tempo de recuperação, não tempo de inferência LLM. A inferência LLM é o gargalo
• SQLite WAL com grafo em memória pode tornar a recuperação rápida
• Isso mede só recuperação, não velocidade de conversa

A experiência real depende de:

• tempo de inferência LLM, muito mais lento que a recuperação
• tamanho da conversa, porque extração de entidades também usa inferência LLM
• volume de dados, porque grafos maiores podem deixar a busca mais lenta

Sugestão: rode mnemo-bench no hardware alvo. Use os números do README como referência, não como promessa.

5. Características local-first e limites

5.1 Vantagens de local-first

O núcleo de local-first é simples: os dados ficam na sua máquina.

Vantagens concretas:

1. Proteção de privacidade

   • Conversas, entidades e relações ficam em SQLite local
   • Não são enviados a um SaaS de terceiros, desde que você use um LLM local

2. Controle dos dados

   • O arquivo SQLite pode ser exportado, copiado em backup e migrado
   • Você não depende da vida de um SaaS. Seus dados continuam com você

3. Portabilidade

   • Ao trocar de máquina, copie o arquivo SQLite
   • Não é preciso “treinar” a memória de novo

4. Depuração

   • SQLite é um formato padrão e pode ser visto com qualquer ferramenta SQLite
   • A estrutura do grafo é visível, não um vetor em caixa-preta

5.2 Riscos e limites

Local-first tem vantagens, mas também riscos:

1. Acúmulo de ruído

   • Extração de entidades não é perfeita e pode errar
   • Entidades erradas afetam recuperações futuras
   • Limpeza periódica é necessária, mas Mnemo não oferece limpeza automática
   • O acúmulo de ruído não é exclusivo do Mnemo; todo sistema automático de memória sofre com isso. A diferença é que o grafo do Mnemo é visível. Você enxerga entidades ruidosas e relações erradas. Em sistemas vetoriais, o ruído fica escondido nos vetores. Isso é uma vantagem do grafo e também uma carga de manutenção

2. Limites de exclusão e recuperação

   • A API atual exclui uma entidade, um trecho de memória ou todo o conteúdo com um cabeçalho de confirmação
   • Não há transação de alto nível para desfazer a última escrita ou uma decisão completa
   • Se um erro se espalhou por várias entidades e relações, use dados de source ou session para delimitar o que excluir antes de restaurar um backup
   • Adicione source, session_id e um identificador de auditoria a decisões importantes e valide a extração antes de salvar fatos reais

3. Estado oculto

   • A estrutura do grafo pode conter relações que você não percebe
   • A recuperação pode devolver resultados sem explicar claramente por que eles apareceram

4. Limites de aplicação

   • Com grande volume de dados, SQLite + grafo em memória pode sofrer pressão
   • O uso compartilhado entre agentes exige autorização, isolamento e operação que o Mnemo não fornece sozinho

5.3 Tabela de decisão: quando usar e quando evitar

Julgamento: se o cenário é “projeto pessoal, alta privacidade, Ollama existente e volume moderado”, Mnemo vale um teste. Se é “grande volume, colaboração em equipe e memória global compartilhada”, espere maturidade ou avalie outra solução.

Recomendações concretas:

• Rode primeiro o caminho Docker em um ambiente de teste e observe estrutura do grafo, qualidade da extração de entidades e resultado da recuperação
• Use conversas de teste para medir risco de ruído. Diga coisas irrelevantes de propósito e veja se Mnemo as identifica errado
• Prepare um plano de limpeza. Entenda cedo a estrutura SQLite para saber apagar entidades incorretas manualmente
• Acompanhe atualizações do README. O projeto é jovem, então APIs, arquitetura e comandos de deploy podem mudar

6. Próximo passo: navegação da série

Se você ainda não leu os artigos anteriores da série de LLM local com Ollama, siga esta ordem:

1. Guia inicial do Ollama: o primeiro passo para rodar um grande modelo de linguagem localmente

   • Comece aqui se ainda não instalou o Ollama

2. Chamadas de API do Ollama: do curl à interface compatível com OpenAI SDK

   • Mnemo usa uma API compatível com OpenAI, então vale entender a superfície da API do Ollama

3. Ollama Embedding na prática: busca vetorial local e RAG

   • Serve para comparar busca vetorial pura com a cadeia de texto completo, entidades e grafo do Mnemo

4. Gestão de memória para AI Agent: memória de longo prazo e governança do conhecimento

   • Mnemo é uma ferramenta de camada de memória; este artigo trata da governança de memória de agentes

Depois desses quatro artigos, instale o Mnemo e rode o caminho Docker localmente. O primeiro resultado útil é ver como o grafo de conhecimento realmente se parece.