Mengram

Dê aos seus agentes de IA uma memória que realmente aprende

Website · Obter chave de API · Documentação · Console · Exemplos

pip install mengram-ai   # or: npm install mengram-ai

mengram try              # see what memory would know about you — local only,
                         # no account, nothing leaves your machine

from mengram import Mengram
m = Mengram(api_key="om-...")           # Free key → mengram.io

m.add([{"role": "user", "content": "I use Python and deploy to Railway"}])
m.search("tech stack")                  # → facts
m.ask("what's my tech stack?")          # → synthesized answer + citations
m.episodes(query="deployment")          # → events
m.procedures(query="deploy")            # → workflows that evolve from failures

Multilíngue nativo: pergunte em russo, chinês, espanhol, japonês — Mengram recupera e responde em 23 idiomas (embeddings multilíngues Cohere + rerank).

Instale com um único prompt (qualquer ferramenta de IA)

Cole isto no Claude Desktop, Cursor, Codex, Claude Code ou Windsurf — o agente lê nosso guia de configuração, instala o SDK, configura o servidor MCP e verifica o ciclo completo de ponta a ponta. Sem alternância de contexto no terminal.

Install Mengram for me. Fetch the canonical install guide at
https://mengram.io/agent-install.txt and follow it precisely.
My email is YOUR_EMAIL_HERE.

Funciona em qualquer agente com ferramentas de shell + edição de arquivos + busca na web. Prefere fazer manualmente? Veja o guia em texto simples — ele também é estruturado para olhos humanos.

Claude Code — Memória que sobrevive a /clear E à compactação automática

Memória persistente que sobrevive a /clear, compactação automática, trocas de máquina e transferências de equipe — o hook SessionStart é acionado após cada compactação e reinjeta seu contexto. O resumo pode ser com perdas; a memória não é.

# 1. Get a free key at https://mengram.io and save it once
mkdir -p ~/.mengram && echo '{"api_key": "om-your-key-here"}' > ~/.mengram/config.json

# 2. Install the plugin (hooks + MCP server + skill)
claude plugin marketplace add alibaizhanov/mengram
claude plugin install mengram@mengram

# 3. Skip the cold start — import your existing session history
#    (secrets are redacted on your machine before anything is uploaded)
mengram import claude-code

O que acontece:

Session Start  →  Loads your cognitive profile (fires after /clear, compaction, and restarts)
Every Prompt   →  Searches past sessions for relevant context (auto-recall)
After Response →  Saves new knowledge in background (auto-save)

Sem salvamentos manuais. Sem chamadas de ferramentas. O Claude simplesmente sabe no que você trabalhou ontem — mesmo depois que a compactação consumiu a transcrição.

Prefere hooks gerenciados por CLI em vez do plugin? pip install mengram-ai && mengram setup faz o mesmo via mengram hook install.

Por que Mengram?

Toda ferramenta de memória de IA armazena fatos. Mengram armazena 3 tipos de memória — e procedimentos evoluem quando falham.

Comece em 30 segundos

1. Instale

pip install mengram-ai

2. Configuração — um comando faz tudo: conta, hooks do Claude Code, configurações MCP para ferramentas detectadas (Cursor, Claude Desktop, Windsurf), importação de histórico e uma verificação de ciclo completo

mengram setup

Ou obtenha uma chave manualmente em mengram.io e export MENGRAM_API_KEY=om-...

3. Use

from mengram import Mengram

m = Mengram(api_key="om-...")

# Add a conversation — auto-extracts facts, events, and workflows
m.add([
    {"role": "user", "content": "Deployed to Railway today. Build passed but forgot migrations — DB crashed. Fixed by adding a pre-deploy check."},
])

# Search across all 3 memory types at once
results = m.search_all("deployment issues")
# → {semantic: [...], episodic: [...], procedural: [...]}

# Upload a PDF — auto-extracts memories using vision AI
result = m.add_file("meeting-notes.pdf")
# → {"status": "accepted", "job_id": "job-...", "page_count": 12}

# Poll for completion
m.job_status(result["job_id"])

// Node.js — pass a file path
await m.addFile('./report.pdf');

// Browser — pass a File object from <input type="file">
await m.addFile(fileInput.files[0]);

# REST API
curl -X POST https://mengram.io/v1/add_file \
  -H "Authorization: Bearer om-..." \
  -F "file=@meeting-notes.pdf" \
  -F "user_id=default"

npm install mengram-ai

const { MengramClient } = require('mengram-ai');
const m = new MengramClient('om-...');

await m.add([{ role: 'user', content: 'Fixed OOM by adding Redis cache layer' }]);
const results = await m.searchAll('database issues');
// → { semantic: [...], episodic: [...], procedural: [...] }

# Add memory
curl -X POST https://mengram.io/v1/add \
  -H "Authorization: Bearer om-..." \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "I prefer dark mode and vim keybindings"}]}'

# Search all 3 types
curl -X POST https://mengram.io/v1/search/all \
  -H "Authorization: Bearer om-..." \
  -d '{"query": "user preferences"}'

3 tipos de memória

Semântica — fatos, preferências, conhecimento

m.search("tech stack")
# → ["Uses Python 3.12", "Deploys to Railway", "PostgreSQL with pgvector"]

Episódica — eventos, decisões, resultados

m.episodes(query="deployment")
# → [{summary: "DB crashed due to missing migrations", outcome: "resolved", date: "2025-05-12"}]

Procedural — fluxos de trabalho que evoluem

Week 1:  "Deploy" → build → push → deploy
                                         ↓ FAILURE: forgot migrations
Week 2:  "Deploy" v2 → build → run migrations → push → deploy
                                                          ↓ FAILURE: OOM
Week 3:  "Deploy" v3 → build → run migrations → check memory → push → deploy ✅

Isso acontece automaticamente quando você relata falhas:

m.procedure_feedback(proc_id, success=False,
                     context="OOM error on step 3", failed_at_step=3)
# → Procedure evolves to v3 with new step added

Cada revisão orientada por falha registra qual suposição se revelou falsa — não apenas qual etapa falhou — e deriva uma pré-condição que acompanha o procedimento no momento da recuperação:

{
  "version": 3,
  "violated_assumption": "the build container had enough memory for a full build",
  "preconditions": ["check available memory before building"],
  "success_count": 11, "fail_count": 2
}

Um agente que carrega a v3 não repete os dois erros que a produziram — e sabe o que verificar antes de confiar no fluxo de trabalho.

Ou totalmente automático — basta adicionar conversas e Mengram detecta falhas e evolui procedimentos:

m.add([{"role": "user", "content": "Deploy failed again — OOM on the build step"}])
# → Episode created → linked to "Deploy" procedure → failure detected → v3 created

Pergunte à sua memória (RAG integrado)

m.ask() retorna uma resposta sintetizada com citações — não uma lista bruta de fatos. Mengram incorpora sua consulta, recupera os fatos mais relevantes e usa Cohere Chat para escrever uma resposta fundamentada com atribuição nativa de fontes.

result = m.ask("what programming languages do I use?")

print(result["answer"])
# 'You use Python and Rust. Python is your daily language [1] and
#  Rust is your favorite [2]. You also know Java for enterprise
#  systems [3].'

for cit in result["citations"]:
    print(f'  "{cit["text"]}" → {cit["sources"][0]["fact"]}')
# "Python and Rust" → uses Python daily for backend development
# "favorite [2]"   → Rust is favorite language
# "Java"           → specializes in Java/Spring Boot

Multilíngue: pergunte em qualquer um dos 23 idiomas, obtenha uma resposta no mesmo idioma com citações que remetem aos fatos no idioma original em que foram armazenados. Recurso premium (Pro / Growth / Business).

Perfil cognitivo

Uma única chamada de API gera um prompt de sistema a partir de todas as memórias:

profile = m.get_profile()
# → "You are talking to Ali, a developer in Almaty. Uses Python, PostgreSQL,
#    and Railway. Recently debugged pgvector deployment. Prefers direct
#    communication and practical next steps."

Insira no prompt de sistema de qualquer LLM para personalização instantânea.

Importar dados existentes

Elimine o problema do início frio:

mengram import chatgpt ~/Downloads/chatgpt-export.zip --cloud   # ChatGPT history
mengram import obsidian ~/Documents/MyVault --cloud              # Obsidian vault
mengram import files notes/*.md --cloud                          # Any text/markdown

Integrações

mengram hook install

{
  "mcpServers": {
    "mengram": {
      "command": "mengram",
      "args": ["server", "--cloud"],
      "env": { "MENGRAM_API_KEY": "om-..." }
    }
  }
}

from langchain_mengram import (
    MengramRetriever,
    MengramChatMessageHistory,
)

retriever = MengramRetriever(api_key="om-...")
docs = retriever.invoke("deployment issues")

from integrations.crewai import create_mengram_tools

tools = create_mengram_tools(api_key="om-...")
# → 5 tools: search, remember, profile,
#   save_workflow, workflow_feedback

agent = Agent(role="Support", tools=tools)

openclaw plugins install openclaw-mengram

mengram search "deployment" --cloud
mengram profile --cloud
mengram import chatgpt export.zip --cloud
mengram hook install

{
  "mcp_servers": [{
    "type": "url",
    "name": "mengram",
    "url": "https://mengram.io/mcp/sse"
  }]
}

POST https://mengram.io/v1/add
POST https://mengram.io/v1/search

Isolamento multiusuário

Uma chave de API, muitos usuários — cada um vê apenas seus próprios dados:

m.add([...], user_id="alice")
m.add([...], user_id="bob")

m.search_all("preferences", user_id="alice")  # Only Alice's memories
m.get_profile(user_id="alice")                 # Alice's cognitive profile

Cliente assíncrono

Cliente Python não bloqueante baseado em httpx:

from mengram import AsyncMengram

async with AsyncMengram() as m:
    await m.add([{"role": "user", "content": "I use async/await"}])
    results = await m.search("async")
    profile = await m.get_profile()

Instale com pip install mengram-ai[async].

Filtros de metadados

Filtre resultados de busca por metadados:

results = m.search("config", filters={"agent_id": "support-bot", "app_id": "prod"})

Webhooks

Receba notificações quando as memórias mudarem:

m.create_webhook(
    url="https://your-app.com/hook",
    event_types=["memory_add", "memory_update"],
)

Modelos de agente

Clone, defina a chave de API, execute em 5 minutos:

cd examples/devops-agent && pip install -r requirements.txt
export MENGRAM_API_KEY=om-...
python main.py

Uso com agentes de IA

Mengram funciona como um backend de memória persistente para agentes autônomos. Seu agente armazena o que aprende e recupera na próxima execução — tornando-se mais inteligente com o tempo.

from mengram import Mengram

m = Mengram(api_key="om-...")

# Agent completes a task → store what happened
m.add([
    {"role": "user", "content": "Apply to Acme Corp on Greenhouse"},
    {"role": "assistant", "content": "Applied successfully. Had to use React Select workaround for dropdowns."},
])
# → Extracts: fact ("applied to Acme Corp"), episode ("Greenhouse application"),
#   procedure ("React Select dropdown workaround")

# Next run → agent recalls what worked before
context = m.search_all("Greenhouse application tips")
# → Returns past procedures, failures, and successful strategies

# Report outcome → procedures evolve
m.procedure_feedback(proc_id, success=False,
                     context="Dropdown fix stopped working")
# → Procedure auto-evolves to a new version

Funciona com qualquer framework de agente — CrewAI, LangChain, AutoGPT, loops personalizados. O agente apenas chama add() após ações e search() antes de decisões.

Self-Hosted (Ollama)

Ao executar localmente com Ollama, use modelos com 8B+ parâmetros e janela de contexto de 8K+. O prompt de extração tem ~4.000 tokens — modelos menores alucinarão ou misturarão exemplos com dados reais.

Referência da API

Documentação interativa completa: mengram.io/docs

Cabeçalhos de cota

Toda resposta autenticada inclui cabeçalhos de uso:

Os SDKs expõem isso via .quota:

m.search("test")
print(m.quota)  # {"add": {"used": 5, "limit": 30}, "search": {"used": 12, "limit": 100}}

Comunidade

• Issues no GitHub — relatórios de bugs, solicitações de recursos
• Discussões no GitHub — mostre seu caso de uso, faça perguntas
• Documentação da API — UI Swagger interativa
• Exemplos — modelos de agente prontos para executar

Histórico de estrelas

Licença

Apache 2.0 — gratuito para uso comercial.