YantrikDB

Servidor MCP YantrikDB

YantrikDB — Memória cognitiva para agentes de IA. Recordação semântica persistente, grafo de conhecimento, detecção de contradições e aprendizado procedural. Disponível como mecanismo embutível, banco de dados em rede ou servidor MCP.

Funciona com Claude Code, Cursor, Windsurf, Hermes Agent, Prime Agent e qualquer cliente compatível com MCP. Inclui uma habilidade portátil Agent Skills — skills/persistent-memory — que ensina a qualquer estrutura compatível o caminho dourado da memória.

Site: yantrikdb.com · Documentação: yantrikdb.com/guides/mcp · GitHub: yantrikos/yantrikdb-mcp · Artigo: Skill as Memory, Not Document

Cada valor na tela é a resposta do próprio servidor via MCP — driver: docs/demo/demo.py, gravado com docs/demo/demo.tape.

Visão geral

O que é	Um servidor MCP que dá a qualquer agente de IA compatível com MCP memória persistente, estruturada e consultável entre sessões
Instalação	pip install yantrikdb-mcp
Funciona com	Claude Code, Cursor, Windsurf, Continue, Claude Desktop, Hermes Agent, Prime Agent, qualquer cliente MCP
Armazenamento	SQLite local em ~/.yantrikdb/memory.db (ou qualquer caminho; ou cluster HTTP)
Embedder	Embedder Rust de 64 dimensões incluso (padrão), ONNX MiniLM de 384 dimensões (extra [onnx]), multilíngue de 256 dimensões (101 idiomas)
Ferramentas	20 — remember, recall, forget, correct, think, memory, graph, conflict, trigger, session, temporal, procedure, category, personality, stats, skill, gaps, conversation, task, atlas
Licença	MIT (mecanismo: Apache-2.0)
Privacidade	Todos os dados na sua máquina. Sem telemetria. Sem serviços externos.

Instalação

# Default — uses the engine's bundled 64-dim embedder. ~10 MB install,
# ~80 ms cold start, no native ML deps.
pip install yantrikdb-mcp

# Optional: higher-quality 384-dim ONNX MiniLM-L6-v2 embedder (~150 MB install).
# Auto-used when an existing pre-v0.6 database is detected.
pip install 'yantrikdb-mcp[onnx]'

Atualizando da v0.5.x? Seu banco de dados existente permanece em 384 dimensões — instale o extra [onnx] para continuar usando-o de forma transparente. Novas instalações usam por padrão o embedder compacto incluso. A v0.7.0+ fixa a correção de migração do mecanismo automaticamente. Consulte Backends de embedder abaixo.

Configuração

O servidor MCP tem três modos de implantação. Escolha o que se adequa à sua configuração.

Modo 1 — Local (padrão, recomendado para usuário único)

O servidor MCP executa o mecanismo em processo com um banco de dados SQLite local. Rápido, privado, zero dependências.

{
  "mcpServers": {
    "yantrikdb": {
      "command": "uvx",
      "args": ["yantrikdb-mcp"]
    }
  }
}

uvx baixa e executa o servidor sob demanda, então isso funciona sem etapa de instalação (requer uv no PATH). Se você instalou o pacote manualmente com pip ou pipx, "command": "yantrikdb-mcp" sem args é equivalente.

É isso. O agente recorda contexto automaticamente, memoriza decisões automaticamente e detecta contradições automaticamente — sem necessidade de prompts.

Modo 2 — Cluster HTTP (recomendado para configurações compartilhadas/multimáquina)

Encaminha todas as chamadas de ferramenta para um cluster HTTP YantrikDB em vez de usar um mecanismo embutido. O servidor MCP é um cliente stateless fino — todas as memórias vivem no cluster, acessíveis de qualquer máquina.

Benefícios: memória compartilhada entre máquinas, alta disponibilidade, sem download de embedder local, sem banco de dados local.

{
  "mcpServers": {
    "yantrikdb": {
      "command": "uvx",
      "args": ["yantrikdb-mcp"],
      "env": {
        "YANTRIKDB_SERVER_URL": "http://node1:7438,http://node2:7438",
        "YANTRIKDB_TOKEN": "ydb_your_database_token"
      }
    }
  }
}

• Separe por vírgula vários nós para descoberta automática de cluster Raft
• Seguimento automático de líder em failover
• Timeout de requisição de 15s
• Obtenha o token do cluster: yantrikdb token create --db your_database

Modo 3 — Servidor SSE (legado, instância remota única)

Execute o próprio servidor MCP como um servidor SSE de longa duração com seu próprio banco de dados embutido. Os clientes se conectam via streaming HTTP.

# Generate a secure API key
export YANTRIKDB_API_KEY=$(python -c "import secrets; print(secrets.token_urlsafe(32))")

# Start SSE server
yantrikdb-mcp --transport sse --port 8420

{
  "mcpServers": {
    "yantrikdb": {
      "type": "sse",
      "url": "http://your-server:8420/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Suporta transportes sse e streamable-http. Nota: conexões SSE podem cair em ociosidade — o Modo 2 (Cluster HTTP) é mais confiável para implantações compartilhadas.

Variáveis de ambiente

Variável	Usada no Modo	Padrão	Descrição
YANTRIKDB_SERVER_URL	Cluster	(não definido → modo local)	URLs de nós do cluster separadas por vírgula
YANTRIKDB_TOKEN	Cluster	(nenhum)	Token Bearer para o banco de dados do cluster
YANTRIKDB_DB_PATH	Local	~/.yantrikdb/memory.db	Caminho do arquivo do banco de dados
YANTRIKDB_EMBEDDER	Local	auto	Seletor de backend: auto | bundled | onnx | multilingual
YANTRIKDB_EMBEDDING_MODEL	Local	all-MiniLM-L6-v2	Nome do modelo ONNX (usado apenas quando YANTRIKDB_EMBEDDER=onnx)
YANTRIKDB_SKILLS_WRITE_ENABLED	Todos	false	Defina true para permitir que agentes criem habilidades via skill(action="define") (consulte Substrato de habilidades abaixo)
YANTRIKDB_OUTCOMES_WRITE_ENABLED	Todos	true	Rastreamento de resultados via skill(action="outcome"). Ativado por padrão para que o ciclo de feedback funcione imediatamente; defina false para bloquear o substrato de resultados. Adicionado na v0.8.1 conforme #8
YANTRIKDB_API_KEY	Servidor SSE	(nenhum)	Token Bearer ao servir SSE/HTTP

Backends de embedder

O modo local inclui três embedders. O MCP escolhe um automaticamente; substitua com YANTRIKDB_EMBEDDER.

Backend	Dim	Inicialização a frio	Tamanho da instalação	Cobertura de idiomas	Quando é usado
bundled (padrão do mecanismo)	64	~80 ms	~10 MB	Somente inglês	Bancos de dados novos / vazios (selecionado automaticamente)
onnx (MiniLM-L6-v2)	384	~2 s	~150 MB	Inglês (maior recall)	Bancos de dados pré-v0.6 existentes (selecionado automaticamente), ou quando definido explicitamente
multilingual (potion-multilingual-128M)	256	~2 s + ~460 MB de download no primeiro uso	~10 MB pip + ~500 MB de cache de modelo	101 idiomas (tokenizador BGE-M3)	Somente opt-in via YANTRIKDB_EMBEDDER=multilingual

auto (padrão) lê o arquivo SQLite em YANTRIKDB_DB_PATH e escolhe onnx se já contiver memórias — preservando a qualidade de recall em atualizações — e bundled caso contrário. Multilíngue nunca é selecionado automaticamente porque seus vetores de 256 dimensões são incompatíveis com bancos de dados existentes (64 dimensões) ou ONNX (384 dimensões); somente opt-in em bancos de dados novos.

Defina YANTRIKDB_EMBEDDER=bundled|onnx|multilingual para substituir. Se você definir YANTRIKDB_EMBEDDER=onnx (ou a detecção automática o escolher) sem instalar os extras, o servidor falha rapidamente com uma dica de instalação:

RuntimeError: Existing DB has memories embedded with the 384-dim ONNX
model, but ONNX deps are missing.
  Install with:  pip install 'yantrikdb-mcp[onnx]'

Para o backend multilíngue, o mecanismo baixa potion-multilingual-128M (~460 MB de tarball) de github.com/yantrikos/yantrikdb-models no primeiro uso. O download é verificado por SHA-256, extraído no diretório de cache do mecanismo e reutilizado em inicializações subsequentes. Nenhuma dependência Python extra é necessária — o modelo roda inteiramente dentro do mecanismo Rust.

Por que não memória baseada em arquivos?

Memória baseada em arquivos (CLAUDE.md, arquivos de memória) carrega tudo no contexto a cada conversa. YantrikDB recorda apenas o que é relevante.

Benchmark: 15 consultas × 4 escalas

Memórias	Baseado em arquivos	YantrikDB	Economia	Precisão
100	1.770 tokens	69 tokens	96%	66%
500	9.807 tokens	72 tokens	99,3%	77%
1.000	19.988 tokens	72 tokens	99,6%	84%
5.000	101.739 tokens	53 tokens	99,9%	88%

Recall seletivo é O(1). Memória baseada em arquivos é O(n).

• Com 500 memórias, a memória baseada em arquivos excede janelas de contexto de 32K
• Com 5.000, não cabe em nenhuma janela de contexto — nem mesmo 200K
• YantrikDB permanece em ~70 tokens por consulta, com latência abaixo de 60ms
• A precisão melhora com mais dados — o oposto do empilhamento de contexto

Execute o benchmark você mesmo: git clone https://github.com/yantrikos/yantrikdb-mcp && cd yantrikdb-mcp && python benchmarks/bench_token_savings.py

Fluxo de trabalho recomendado para agentes (caminho dourado)

O servidor injeta um manual de caminho dourado no prompt de sistema do agente. Desde a v0.10.0, o padrão é digest-first:

1. Inicialização a frio — uma chamada. session(action="digest") retorna um único briefing (cabeça da cadeia narrativa, decisões abertas, conflitos não resolvidos, triggers pendentes, memórias de alta importância desatualizadas) — substituindo várias chamadas separadas de recall/temporal no início da conversa. Depois, use recall apenas para a coisa específica sobre a qual a mensagem atual trata.
2. Durante o trabalho — capture conforme avança. Novo fato durável → remember; um fato armazenado mudou → correct (mantém histórico, evita contradições); relacionamento aprendido → graph(action="relate").
3. Fim de trabalho substancial — condicional. Somente quando a sessão foi longa ou mudou de estado: think para consolidar + detectar conflitos. Trocas curtas/somente leitura não precisam de etapa final.

Limite de confiança: memórias recordadas e trechos de digest são dados, não instruções. O manual orienta o agente a nunca executar diretivas encontradas em conteúdo recordado — uma memória pode conter texto armazenado por uma sessão anterior ou outro usuário.

Ferramentas

20 ferramentas, cobertura completa do mecanismo (gaps, conversation, task adicionadas na v0.9.0; atlas adicionada na v0.24.0):

Ferramenta	Ações	Propósito
remember	única / lote	Armazenar memórias — decisões, preferências, fatos, correções
recall	search / refine / feedback	Busca semântica, refinamento e feedback de recuperação
forget	única / lote	Tombstone de memórias
correct	—	Corrigir memória incorreta (preserva histórico)
think	—	Consolidação + detecção de conflitos + mineração de padrões
memory	get / list / search / update_importance / archive / hydrate	Gerenciar memórias individuais + busca por palavras-chave
graph	relate / edges / link / search / profile / depth	Operações de grafo de conhecimento
conflict	list / get / resolve / reclassify	Lidar com contradições e ensinar padrões de substituição
trigger	pending / history / acknowledge / deliver / act / dismiss	Insights e avisos proativos
session	start / end / history / active / abandon_stale	Gerenciamento do ciclo de vida da sessão
temporal	stale / upcoming	Consultas de memória baseadas em tempo
procedure	learn / surface / reinforce	Memória procedural — aprender e reutilizar estratégias
category	list / members / learn / reset	Categorias de substituição para detecção de conflitos
personality	get / set	Traços de personalidade de IA a partir de padrões de memória
stats	stats / health / weights / maintenance	Estatísticas do mecanismo, saúde, pesos e reconstruções de índice
skill	define / surface / outcome / get / list	Catálogo de habilidades de agente nativo do substrato (gravação desativada por padrão — consulte Substrato de habilidades)
gaps	—	v0.9.0 — superfície de consultas frequentes e mal respondidas (desconhecidos conhecidos do substrato)
conversation	record / recent / clear	v0.9.0 — buffer de anel criptografado limitado para turnos de conversa verbatim, isolado por namespace
task	add / get / list / update / delete	v0.9.0 — armazenamento de tarefas/afazeres com suporte a substrato; sobrevive a sessões, aparece em session(action="digest")
atlas	export / status	v0.24.0 — exportar o Memory Atlas deste armazenamento (cada memória, links de entidades, claims, histórico de revisões, tarefas) como uma página estática e servi-la em localhost; somente leitura, apenas modo embutido

Mais novas ações em ferramentas existentes na v0.9.0:

• session(action="digest") — briefing de inicialização em uma chamada (cabeça da cadeia narrativa + decisões abertas + conflitos + triggers)
• think(maintenance_cycle=True) — ciclo de sono de higiene autônomo
• think(last_cycle_only=True) — ler o último resumo do ciclo sem executar
• stats(action="audit_leak") — auditoria de privacidade / candidatos a vazamento
• stats(action="skill_outcomes") — contagem durável de resultados de habilidades
• graph(action="auto_relate" / "record_link" / "record_unlink" / "linked_records" / "recall_with_links") — arestas de co-ocorrência + links registro-a-registro + recall expandido por links
• conflict(action="auto_resolve") — eliminar conflitos inequívocos em uma passada
• memory(action="chain_head" / "history") — cabeça do namespace de cadeia + histórico de revisões
• trigger(action="prune") — limitar o backlog de triggers pendentes
• remember(summary=...) — modo rascunho: o mecanismo atomiza um resumo longo em fatos semânticos vinculados (captura automática no fim da sessão)

Consulte yantrikdb.com/guides/mcp para documentação completa.

Substrato de habilidades (v0.8.0+)

O YantrikDB expõe um catálogo estruturado de habilidades de agente — separado de memórias soltas procedure. As habilidades possuem esquema (skill_id, applies_to, triggers, body, type) e são armazenadas no namespace dedicado skill_substrate, para que múltiplos consumidores (este MCP, yantrikdb-hermes-plugin, SDK Lane B, WisePick, endpoints /v1/skills/* do yantrikdb-server) leiam e escrevam no mesmo substrato. Contexto: Sarkar 2026 — Skill as Memory, Not Document.

Modelo de segurança

Escritas de habilidades moldam o comportamento futuro do agente entre sessões, então o servidor MCP implementa defesa em profundidade. Cada controle possui uma chave de variável de ambiente (travada na inicialização — C2) e o estado completo é exposto via stats(action="stats") e o log de auditoria.

Controles em camadas (cada um vem ativado por padrão, salvo indicação):

Camada	Controle	Variável de ambiente	Notas
Esquema	regex skill_id, corpo de 50–5000 caracteres, applies_to de 1–10 entradas, enum skill_type	(sempre ativo)	Mesmo conjunto de regex do yantrikdb-server /v1/skills/define
A1 Marcadores de injeção de prompt	Rejeita corpos contendo padrões de confusão de papel / "ignore instruções anteriores"	YANTRIKDB_SKILLS_DISABLE_SCANNERS=A1 para desativar (auditado)	OWASP LLM01
A2 Scanner de credenciais	Chaves AWS/GitHub/Slack/Stripe/Google/Anthropic/OpenAI, chaves privadas SSH/PGP, JWT, atribuições de senha	=A2 para desativar	Subconjunto do secret-scanning do GitHub
A3 Bloqueio de URL/IP	Rejeita http(s), ftp, literais IPv4 no corpo	YANTRIKDB_SKILLS_ALLOW_URLS=true para permitir	Caminho de exfiltração para agentes downstream
A4 Evasão Unicode	Rejeita caracteres não imprimíveis (Cf/Cs/Cn exceto na lista de permissão)	=A4 para desativar	Override Bidi (U+202E), espaços de largura zero
A5 Payload codificado	Rejeita sequências ≥200 caracteres de base64/hex	=A5 para desativar	Heurística — propensa a falsos positivos para hashes grandes
B1 Lista de permissão de namespace	O primeiro segmento de skill_id deve estar na lista do operador	YANTRIKDB_SKILLS_ALLOWED_NAMESPACES=workflow,review	Não definido = todos permitidos
B2 Atribuição de autor	Registra session_id, os_user, hostname, wall_clock, audit_nonce	(sempre ativo)	Trilha forense
B3 Substituição entre origens	Recusa sobrescrever uma habilidade escrita por um consumidor diferente	YANTRIKDB_SKILLS_ALLOW_CROSS_ORIGIN_REPLACE=true para permitir	Defende contra colisão MCP↔hermes-plugin
B4 Integridade de substituição	supersedes deve referenciar uma habilidade existente no mesmo namespace	(sempre ativo)	Bloqueia aposentadoria maliciosa de habilidades legítimas
C1 Portão com limite de tempo	O portão fecha automaticamente no timestamp (aplica-se tanto a define quanto a outcome)	YANTRIKDB_SKILLS_WRITE_EXPIRES_AT=2026-12-31T00:00:00Z	Não definido = sem expiração
C1.5 Portão dividido de outcome	A ação outcome usa seu próprio portão, padrão ATIVADO	YANTRIKDB_OUTCOMES_WRITE_ENABLED=false para travar outcomes também	v0.8.1+: define e outcome têm perfis de ameaça diferentes — outcome não pode introduzir novas instruções, apenas anexar {succeeded, note≤500} a uma habilidade existente. O loop de feedback funciona por padrão; trave explicitamente se necessário
C2 Configuração travada	Todas as variáveis de ambiente YANTRIKDB_SKILLS_* / YANTRIKDB_OUTCOMES_* são lidas uma vez na inicialização	(sempre ativo)	Mutar env em um subprocesso não pode contornar o portão
D1 Log de auditoria	Anexo JSONL de cada evento de aceitar/rejeitar/adulteração	YANTRIKDB_SKILLS_AUDIT_LOG=/var/log/yantrikdb/skills.jsonl	Não definido = sem auditoria (avisa na inicialização)
D2 Limite de taxa	Limite de escrita por janela deslizante por ID de sessão	YANTRIKDB_SKILLS_WRITE_RATE=30 (padrão escritas/min)	Derrota ataques de inundação
D3 Guardas de Outcome.note	Nota ≤500 caracteres + verificada por A1/A2/A4	(sempre ativo)	Fecha o canal lateral de outcome
D4 Contadores em stats	Contagens de aceitar/rejeitar por motivo, exibidas em stats(action="stats")["skill_substrate"]	(sempre ativo)	Painéis do operador
E1 SHA-256 do corpo	Armazenado na escrita, reverificado em cada leitura	(sempre ativo)	Detecta adulteração fora de banda no banco — surface/get omitem incompatibilidades e registram no log de auditoria
E2 Origem do autor	Tag metadata.author_origin — padrão yantrikdb-mcp	YANTRIKDB_SKILLS_AUTHOR_ORIGIN=... para sobrescrever	Rastreia proveniência do substrato entre consumidores
F Segurança na inicialização	Avisos na inicialização sobre configurações perigosas	(sempre ativo)	Registra [F.1]–[F.5] em stderr + auditoria
G Fila de revisão para rule	Habilidades do tipo rule são roteadas para skill_pending_review (não exibidas por surface/get/list)	YANTRIKDB_SKILLS_RULE_REQUIRES_REVIEW=false para desativar (não recomendado)	Regras influenciam a política do agente — aprovação humana necessária
Guarda multi-tenant	Aviso [F.1] se o banco mostrar múltiplos IDs de ator sem reconhecimento	YANTRIKDB_SKILLS_MULTITENANT_ACK=true	Um banco = um tenant é o padrão seguro

Checklist empresarial:

# Minimum production config when you turn the gate ON:
YANTRIKDB_SKILLS_WRITE_ENABLED=true
YANTRIKDB_SKILLS_WRITE_EXPIRES_AT=2026-12-31T00:00:00Z
YANTRIKDB_SKILLS_ALLOWED_NAMESPACES=workflow,review,onboarding
YANTRIKDB_SKILLS_AUDIT_LOG=/var/log/yantrikdb/skills.audit.jsonl
YANTRIKDB_SKILLS_AUTHOR_ORIGIN=acme-corp-claude-prod
# Defaults are already correct: writes off, scanners on, rate-limit 30/min,
# rule-type routed to review, body-hash verified on read, locked at startup.

O log de auditoria é o registro canônico. Cada aceite, cada rejeição (com o scanner que sinalizou), cada detecção de adulteração na leitura, cada portão fechado por expiração — tudo lá em JSONL. Conecte-o ao seu SIEM.

Exemplo de saída stats(action="stats") (fatia skill_substrate)

"skill_substrate": {
  "counters": {
    "skill_defines_accepted": 12,
    "skill_defines_rejected": {"content_scan:A2": 1, "namespace_not_allowed": 3},
    "skill_outcomes_recorded": 47,
    "skill_pending_review": 2
  },
  "config": {
    "writes_enabled": true,
    "write_expires_at": "2026-12-31T00:00:00+00:00",
    "allowed_namespaces": ["workflow", "review"],
    "audit_log_path": "/var/log/yantrikdb/skills.audit.jsonl",
    "rule_requires_review": true,
    "author_origin": "acme-corp-claude-prod"
  }
}

Esquema (validado no momento da escrita)

Campo	Restrição
skill_id	Segmentos minúsculos separados por ponto, comprimento 4–200, ex.: workflow.git.commit_clean
body	50–5000 caracteres
applies_to	1–10 identificadores minúsculos com sublinhado (sem hífens — essencial para a consistência do substrato)
skill_type	Um de procedure, reference, lesson, pattern, rule
on_conflict	reject (padrão) ou replace

Exemplo de sessão

# Define (requires gate enabled)
skill(action="define",
      skill_id="workflow.git.commit_clean",
      body="Before commit: run pytest, run lint, write a clear subject + body.",
      skill_type="procedure",
      applies_to=["git", "release"])

# Surface relevant skills for the current task
skill(action="surface", query="how to commit cleanly", top_k=5)

# Record an outcome after using the skill (gated, append-only)
skill(action="outcome", skill_id="workflow.git.commit_clean",
      succeeded=True, note="caught a flake8 issue pre-push")

Outcomes são eventos somente de anexação no namespace outcome_substrate — sem consolidação automática na habilidade pai, seguindo a regra de design "esquema, não semântica" do yantrikdb-server. Agentes (ou o operador) podem agregar outcomes por conta própria para calcular taxas de sucesso.

FAQ

O que é o YantrikDB MCP?

O YantrikDB MCP é um servidor Model Context Protocol (MCP) que dá aos agentes de IA memória cognitiva persistente entre sessões. Ele expõe 20 ferramentas (remember, recall, forget, correct, think, graph, conflict, trigger, session, temporal, procedure, category, personality, stats, memory, skill, gaps, conversation, task, atlas) que qualquer cliente compatível com MCP — Claude Code, Cursor, Windsurf, Continue, Claude Desktop — pode chamar automaticamente sem prompts.

Como isso difere de memória baseada em arquivos como CLAUDE.md?

Memória baseada em arquivos carrega tudo no contexto a cada conversa, o que escala O(n) em custo de tokens. O YantrikDB usa recall semântico seletivo — com 5.000 memórias, arquivos custam ~101K tokens por conversa enquanto o YantrikDB custa ~53 tokens. A precisão melhora com mais dados em vez de degradar conforme a janela de contexto enche. Script de benchmark: python benchmarks/bench_token_savings.py.

Como ele se compara a mem0 / Letta / Zep / memória MCP nativa?

Veja a tabela de comparação abaixo. Resumo: o YantrikDB é o único que vem como motor Rust embutível e servidor MCP e banco de dados de rede com a mesma semântica de substrato. É o único com memória procedural de primeira classe + substrato de habilidades validado por esquema na escrita + consolidação autônoma/detecção de conflitos. Também é o único cujo motor subjacente é publicado como artigo revisado por pares (Sarkar 2026, Zenodo DOI 10.5281/zenodo.20128887).

Posso fazer self-host?

Sim — três formas. (1) Local: basta pip install yantrikdb-mcp e aponte seu cliente MCP para ele. O SQLite fica em ~/.yantrikdb/memory.db. (2) Rede: execute yantrikdb-server como um cluster HTTP multi-tenant, aponte o MCP para ele via YANTRIKDB_SERVER_URL. (3) Híbrido: modo servidor SSE (yantrikdb-mcp --transport sse) para implantações compartilhadas.

Meus dados são enviados para algum lugar?

Não. Todos os dados ficam na sua máquina (ou no seu cluster). Sem telemetria, sem serviços de terceiros. O embedder padrão roda inteiramente no motor Rust via lookup estático — sem downloads de modelos ou chamadas de API. Os embedders opcionais [onnx] e multilíngues buscam pesos de modelo uma vez do CDN do HuggingFace e rodam localmente depois.

Qual é a diferença entre procedure e skill?

procedure armazena memórias soltas de como fazer (ranqueadas por eficácia, sem esquema). skill armazena entradas de catálogo estruturadas (skill_id, applies_to, triggers, body, type) em um namespace dedicado skill_substrate compartilhado com yantrikdb-hermes-plugin, SDK Lane B, WisePick e os endpoints /v1/skills/* do yantrikdb-server. Use procedure para notas pessoais de como fazer; use skill para capacidades estruturadas de agente que outros consumidores devem poder exibir.

É seguro habilitar a autoria de habilidades?

Escritas de habilidades estão desativadas por padrão justamente porque podem moldar o comportamento futuro do agente. Quando você liga o portão, sete camadas de defesa em profundidade se aplicam: scanner de injeção de prompt, scanner de credenciais, bloqueio de URL, scanner de evasão Unicode, lista de permissão de namespace, atribuição de autor, log de auditoria, limite de taxa, detecção de adulteração por hash do corpo e uma fila de revisão para habilidades do tipo rule. Veja Modelo de segurança acima.

Funciona em produção?

Sim — o yantrikdb-mcp roda em produção no cluster homelab do YantrikDB (1973+ memórias, transporte SSE, 2 semanas de uptime por ciclo de release) e é a implantação de referência por trás das decisões de release do motor. A v0.8.x adicionou o ritmo de patch no mesmo dia do motor ao próprio servidor MCP: problemas externos registrados por contribuidores da comunidade viram correções lançadas em até 2 horas.

Em que o motor é escrito?

O motor do YantrikDB é Rust (crates.io: yantrikdb) com bindings Python pyo3 (PyPI: yantrikdb). O servidor MCP em si é Python — um wrapper fino sobre os bindings Python do motor, mais o encanamento de transporte stdio/SSE/HTTP.

Comparação com outros sistemas de memória de agente

Capacidade	YantrikDB MCP	mem0	Letta (MemGPT)	Zep	Memória MCP nativa por arquivos
Nativo MCP	✅ primeira classe	via integração customizada	via integração customizada	via integração customizada	✅ em formato de filesystem
Embutível (sem servidor)	✅ Rust + Python	❌ requer serviço	❌ requer serviço	❌ requer serviço	✅ filesystem
Modo banco de dados de rede	✅ cluster HA Raft	✅ Pro / Enterprise	✅ self-host	✅ gerenciado + self-host	❌
Recall semântico (vetor)	✅ HNSW	✅	✅	✅	❌ (apenas grep de arquivos)
Grafo de conhecimento	✅ nós + arestas tipados	✅ (adição recente)	parcial	✅	❌
Detecção de contradição	✅ autônoma	❌	❌	❌	❌
Memória procedural	✅ ranqueada por eficácia	❌	parcial	❌	❌
Substrato de habilidades (validado por esquema)	✅ com 7 camadas de defesa	❌	❌	❌	❌
Consolidação autônoma (think)	✅	❌	parcial	✅	❌
Decaimento temporal + meia-vida	✅ modelo biológico	❌	❌	❌	❌
Gatilhos proativos	✅	❌	❌	❌	❌
Derivação de traços de personalidade	✅ a partir de padrões de memória	❌	❌	❌	❌
Armazenamento	SQLite local + WAL	hospedado	local	local + hospedado	filesystem
Licença	MIT (motor Apache-2.0)	Apache 2.0	Apache 2.0	Apache 2.0	MIT
Artigo revisado por pares	✅ Zenodo	❌	✅ artigo MemGPT	❌	❌
Ritmo de patch no mesmo dia para problemas	✅ (média <2h na v0.8.x)	varia	varia	varia	n/a

As comparações refletem capacidades públicas em maio de 2026. PRs são bem-vindos para corrigir qualquer linha.

Cite este trabalho

Se você usar o YantrikDB em contexto acadêmico ou de pesquisa, cite o artigo do substrato:

@misc{sarkar2026skill,
  author       = {Sarkar, Pranab},
  title        = {Skill as Memory, Not Document: A Database-Native Substrate for Agent Skill Catalogs},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.20128887},
  url          = {https://doi.org/10.5281/zenodo.20128887},
  orcid        = {0009-0009-8683-1481}
}

Citação em texto simples:

Sarkar, P. (2026). Skill as Memory, Not Document: A Database-Native Substrate for Agent Skill Catalogs. Zenodo. https://doi.org/10.5281/zenodo.20128887

Exemplos

1. Auto-recall no início da conversa

Usuário: "O que decidimos sobre a migração do banco de dados?" O agente chama automaticamente recall("database migration decision") e recupera memórias relevantes antes de responder — sem necessidade de solicitação manual.

2. Lembrar decisões + construir grafo de conhecimento

Usuário: "Vamos usar PostgreSQL para o novo serviço. Alice será responsável pela migração."

O agente chama:

• remember(text="Decided to use PostgreSQL for the new service", domain="architecture", importance=0.8)
• remember(text="Alice owns the PostgreSQL migration", domain="people", importance=0.7)
• graph(action="relate", entity="Alice", target="PostgreSQL Migration", relationship="owns")

3. Detecção de contradições

Após armazenar "Usamos Python 3.11" e depois "Atualizamos para Python 3.12", chamar think() detecta o conflito. O agente o apresenta:

"Encontrei uma contradição: você disse anteriormente Python 3.11, mas recentemente mencionou Python 3.12. Qual é o atual?"

Então resolve com conflict(action="resolve", conflict_id="...", strategy="keep_b").

Política de Privacidade

O YantrikDB MCP Server armazena todos os dados localmente na sua máquina (padrão: ~/.yantrikdb/memory.db). Nenhum dado é enviado a servidores externos, nenhuma telemetria é coletada e nenhum serviço de terceiros é contatado durante a operação.

• Coleta de dados: Apenas o que você armazena explicitamente via a ferramenta remember ou o que o agente de IA armazena em seu nome.
• Armazenamento de dados: Banco de dados SQLite local no seu sistema de arquivos. Você controla o caminho via YANTRIKDB_DB_PATH.
• Compartilhamento com terceiros: Nenhum. Os dados nunca saem da sua máquina no modo local (stdio).
• Modo de rede: Ao usar transporte SSE/HTTP, os dados trafegam entre seu cliente e seu servidor auto-hospedado. Nenhum servidor da Anthropic ou de terceiros está envolvido.
• Modelo de embeddings: Usa um modelo ONNX local (all-MiniLM-L6-v2). Os arquivos do modelo são baixados uma vez do Hugging Face Hub no primeiro uso e depois armazenados em cache localmente.
• Retenção: Os dados persistem até que você os exclua (ferramenta forget) ou exclua o arquivo do banco de dados.
• Contato: developer@pranab.co.in

Política completa: yantrikdb.com/privacy

Contribuindo

Consulte CONTRIBUTING.md para configuração de venv, execução de pytest e abertura de PRs.

Suporte

• Problemas: github.com/yantrikos/yantrikdb-mcp/issues
• E-mail: developer@pranab.co.in
• Documentação: yantrikdb.com/guides/mcp

Projetos relacionados

Mesma base de memória, diferentes pontos de entrada:

• yantrikdb — o mecanismo Rust/Python incorporável no qual este servidor roda (pip install yantrikdb).
• yantrikdb-server — gateway HTTP e cluster de alta disponibilidade, para os modos de implantação em rede acima.
• yantrikdb-client — cliente Python tipado para esse servidor.
• langchain-yantrikdb — YantrikDB como VectorStore e ChatMessageHistory do LangChain.
• yantrikdb-hermes-plugin — provedor de memória para NousResearch/hermes-agent, compartilhando a mesma base de habilidades.
• yantrik-memory — camada de memória agnóstica de framework com traits e evolução de vínculos.

Licença

Este servidor MCP é licenciado sob MIT — use-o livremente em qualquer projeto.

Nota: Este pacote depende de yantrikdb (o mecanismo de memória cognitiva), que é licenciado sob Apache-2.0 a partir de 18/08/2026 (anteriormente AGPL-3.0). Tanto este servidor quanto o mecanismo agora possuem licenças permissivas — não há obrigações de copyleft sobre seu código, modificações ou serviços hospedados.