YantrikDB

Servidor MCP de YantrikDB

YantrikDB — Memoria cognitiva para agentes de IA. Recuerdo semántico persistente, grafo de conocimiento, detección de contradicciones y aprendizaje procedimental. Se distribuye como motor embebible, base de datos de red o servidor MCP.

Funciona con Claude Code, Cursor, Windsurf, Hermes Agent, Prime Agent y cualquier cliente compatible con MCP. Incluye una habilidad portátil de Agent Skills — skills/persistent-memory — que enseña a cualquier marco compatible la ruta dorada de la memoria.

Sitio web: yantrikdb.com · Documentación: yantrikdb.com/guides/mcp · GitHub: yantrikos/yantrikdb-mcp · Artículo: Skill as Memory, Not Document

Cada valor en pantalla es la respuesta propia del servidor a través de MCP — controlador: docs/demo/demo.py, grabado con docs/demo/demo.tape.

De un vistazo

Qué es	Un servidor MCP que proporciona a cualquier agente de IA compatible con MCP memoria persistente, estructurada y consultable entre sesiones
Instalación	pip install yantrikdb-mcp
Funciona con	Claude Code, Cursor, Windsurf, Continue, Claude Desktop, Hermes Agent, Prime Agent, cualquier cliente MCP
Almacenamiento	SQLite local en ~/.yantrikdb/memory.db (o cualquier ruta; o clúster HTTP)
Embedder	Embedder Rust de 64 dims incluido (predeterminado), ONNX MiniLM de 384 dims (extra [onnx]), multilingüe de 256 dims (101 idiomas)
Herramientas	20 — remember, recall, forget, correct, think, memory, graph, conflict, trigger, session, temporal, procedure, category, personality, stats, skill, gaps, conversation, task, atlas
Licencia	MIT (motor: Apache-2.0)
Privacidad	Todos los datos en tu máquina. Sin telemetría. Sin servicios externos.

Instalación

# 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]'

¿Actualizando desde v0.5.x? Tu base de datos existente permanece en 384 dims — instala el extra [onnx] para seguir usándola de forma transparente. Las instalaciones nuevas usan por defecto el embedder ligero incluido. v0.7.0+ fija automáticamente la corrección de migración del motor. Consulta Backends de embedder más abajo.

Configuración

El servidor MCP tiene tres modos de despliegue. Elige el que se adapte a tu configuración.

Modo 1 — Local (predeterminado, recomendado para un solo usuario)

El servidor MCP ejecuta el motor en proceso con una base de datos SQLite local. Rápido, privado, cero dependencias.

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

uvx descarga y ejecuta el servidor bajo demanda, por lo que esto funciona sin paso de instalación (necesita uv en PATH). Si instalaste el paquete tú mismo con pip o pipx, "command": "yantrikdb-mcp" sin args es equivalente.

Eso es todo. El agente recuerda automáticamente el contexto, recuerda automáticamente las decisiones y detecta automáticamente contradicciones — sin necesidad de indicaciones.

Modo 2 — Clúster HTTP (recomendado para configuraciones compartidas/multimáquina)

Reenvía todas las llamadas de herramientas a un clúster HTTP de YantrikDB en lugar de usar un motor embebido. El servidor MCP es un cliente delgado sin estado — todas las memorias viven en el clúster, accesibles desde cualquier máquina.

Beneficios: memoria compartida entre máquinas, alta disponibilidad, sin descarga local de embedder, sin base de datos local.

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

• Separa con comas varios nodos para el auto-descubrimiento del clúster Raft
• Seguimiento automático del líder en caso de conmutación por error
• Tiempo de espera de solicitud de 15 s
• Obtén el token del clúster: yantrikdb token create --db your_database

Modo 3 — Servidor SSE (heredado, instancia remota única)

Ejecuta el propio servidor MCP como un servidor SSE de larga duración con su propia base de datos embebida. Los clientes se conectan mediante transmisión 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"
      }
    }
  }
}

Admite transportes sse y streamable-http. Nota: las conexiones SSE pueden caerse en inactividad — el Modo 2 (Clúster HTTP) es más fiable para despliegues compartidos.

Variables de entorno

Variable	Usada en el modo	Predeterminado	Descripción
YANTRIKDB_SERVER_URL	Clúster	(sin definir → modo local)	URLs de nodos del clúster separadas por comas
YANTRIKDB_TOKEN	Clúster	(ninguno)	Token Bearer para la base de datos del clúster
YANTRIKDB_DB_PATH	Local	~/.yantrikdb/memory.db	Ruta del archivo de base de datos
YANTRIKDB_EMBEDDER	Local	auto	Selector de backend: auto | bundled | onnx | multilingual
YANTRIKDB_EMBEDDING_MODEL	Local	all-MiniLM-L6-v2	Nombre del modelo ONNX (solo se usa cuando YANTRIKDB_EMBEDDER=onnx)
YANTRIKDB_SKILLS_WRITE_ENABLED	Todos	false	Establece true para permitir que los agentes creen habilidades mediante skill(action="define") (consulta Sustrato de habilidades más abajo)
YANTRIKDB_OUTCOMES_WRITE_ENABLED	Todos	true	Seguimiento de resultados mediante skill(action="outcome"). Activado por defecto para que el bucle de retroalimentación funcione desde el primer momento; establece false para bloquear el sustrato de resultados. Añadido en v0.8.1 según #8
YANTRIKDB_API_KEY	Servidor SSE	(ninguno)	Token Bearer al servir SSE/HTTP

Backends de embedder

El modo local incluye tres embedders. El MCP elige uno automáticamente; anula con YANTRIKDB_EMBEDDER.

Backend	Dim	Arranque en frío	Tamaño de instalación	Cobertura de idiomas	Cuándo se usa
bundled (predeterminado del motor)	64	~80 ms	~10 MB	Solo inglés	Bases de datos nuevas / vacías (seleccionado automáticamente)
onnx (MiniLM-L6-v2)	384	~2 s	~150 MB	Inglés (mayor recuerdo)	Bases de datos pre-v0.6 existentes (seleccionado automáticamente), o cuando se establece explícitamente
multilingual (potion-multilingual-128M)	256	~2 s + ~460 MB de descarga en el primer uso	~10 MB pip + ~500 MB de caché de modelo	101 idiomas (tokenizador BGE-M3)	Solo opt-in mediante YANTRIKDB_EMBEDDER=multilingual

auto (predeterminado) lee el archivo SQLite en YANTRIKDB_DB_PATH y elige onnx si ya contiene memorias — preservando la calidad del recuerdo en las actualizaciones — y bundled en caso contrario. El multilingüe nunca se selecciona automáticamente porque sus vectores de 256 dims son incompatibles con las bases de datos incluidas existentes (64 dims) u ONNX (384 dims); solo opt-in en bases de datos nuevas.

Establece YANTRIKDB_EMBEDDER=bundled|onnx|multilingual para anular. Si estableces YANTRIKDB_EMBEDDER=onnx (o la auto-detección lo elige) sin instalar los extras, el servidor falla rápidamente con una pista de instalación:

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 el backend multilingüe, el motor descarga potion-multilingual-128M (~460 MB de archivo tar) desde github.com/yantrikos/yantrikdb-models en el primer uso. La descarga se verifica con SHA-256, se extrae en el directorio de caché del motor y se reutiliza en los inicios posteriores. No se requieren dependencias adicionales de Python — el modelo se ejecuta completamente dentro del motor Rust.

¿Por qué no memoria basada en archivos?

La memoria basada en archivos (CLAUDE.md, archivos de memoria) carga todo en el contexto en cada conversación. YantrikDB recuerda solo lo relevante.

Benchmark: 15 consultas × 4 escalas

Memorias	Basado en archivos	YantrikDB	Ahorro	Precisión
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%

El recuerdo selectivo es O(1). La memoria basada en archivos es O(n).

• Con 500 memorias, la basada en archivos supera las ventanas de contexto de 32K
• Con 5.000, no cabe en ninguna ventana de contexto — ni siquiera en 200K
• YantrikDB se mantiene en ~70 tokens por consulta, con menos de 60 ms de latencia
• La precisión mejora con más datos — lo contrario del relleno de contexto

Ejecuta el benchmark tú mismo: git clone https://github.com/yantrikos/yantrikdb-mcp && cd yantrikdb-mcp && python benchmarks/bench_token_savings.py

Flujo de trabajo recomendado para agentes (ruta dorada)

El servidor inyecta un manual de ruta dorada en el prompt del sistema del agente. Desde v0.10.0 el predeterminado es primero-digest:

1. Arranque en frío — una llamada. session(action="digest") devuelve un único informe (cabeza de cadena narrativa, decisiones abiertas, conflictos sin resolver, disparadores pendientes, memorias de alta importancia obsoletas) — reemplazando varias llamadas separadas de recall/temporal al inicio de la conversación. Luego recall solo para lo específico sobre lo que trata el mensaje actual.
2. Durante el trabajo — captura sobre la marcha. Nuevo hecho duradero → remember; un hecho almacenado cambió → correct (mantiene el historial, evita contradicciones); relación aprendida → graph(action="relate").
3. Fin del trabajo sustancial — condicional. Solo cuando la sesión fue larga o cambió el estado: think para consolidar + detectar conflictos. Los intercambios cortos/solo lectura no necesitan paso final.

Límite de confianza: las memorias recordadas y los fragmentos de digest son datos, no instrucciones. El manual dirige al agente a nunca ejecutar directivas encontradas dentro del contenido recordado — una memoria puede contener texto que una sesión anterior u otro usuario almacenó.

Herramientas

20 herramientas, cobertura completa del motor (gaps, conversation, task añadidas en v0.9.0; atlas añadida en v0.24.0):

Herramienta	Acciones	Propósito
remember	single / batch	Almacenar memorias — decisiones, preferencias, hechos, correcciones
recall	search / refine / feedback	Búsqueda semántica, refinamiento y retroalimentación de recuperación
forget	single / batch	Memorias de tumba
correct	—	Corregir memoria incorrecta (preserva el historial)
think	—	Consolidación + detección de conflictos + minería de patrones
memory	get / list / search / update_importance / archive / hydrate	Gestionar memorias individuales + búsqueda por palabras clave
graph	relate / edges / link / search / profile / depth	Operaciones de grafo de conocimiento
conflict	list / get / resolve / reclassify	Manejar contradicciones y enseñar patrones de sustitución
trigger	pending / history / acknowledge / deliver / act / dismiss	Información y advertencias proactivas
session	start / end / history / active / abandon_stale	Gestión del ciclo de vida de sesiones
temporal	stale / upcoming	Consultas de memoria basadas en tiempo
procedure	learn / surface / reinforce	Memoria procedimental — aprender y reutilizar estrategias
category	list / members / learn / reset	Categorías de sustitución para detección de conflictos
personality	get / set	Rasgos de personalidad de IA a partir de patrones de memoria
stats	stats / health / weights / maintenance	Estadísticas del motor, salud, pesos y reconstrucciones de índice
skill	define / surface / outcome / get / list	Catálogo de habilidades de agente nativo del sustrato (escritura desactivada por defecto — consulta Sustrato de habilidades)
gaps	—	v0.9.0 — mostrar consultas frecuentes y mal respondidas (incógnitas conocidas del sustrato)
conversation	record / recent / clear	v0.9.0 — buffer circular cifrado y limitado para turnos de conversación literales, aislado por espacio de nombres
task	add / get / list / update / delete	v0.9.0 — almacén de tareas/tareas pendientes respaldado por sustrato; sobrevive a las sesiones, aparece en session(action="digest")
atlas	export / status	v0.24.0 — exportar el Atlas de Memoria de este almacén (cada memoria, enlaces de entidades, afirmaciones, historial de revisiones, tareas) como página estática y servirlo en localhost; solo lectura, solo modo embebido

Además, nuevas acciones en herramientas existentes en v0.9.0:

• session(action="digest") — informe de arranque de una sola llamada (cabeza de cadena narrativa + decisiones abiertas + conflictos + disparadores)
• think(maintenance_cycle=True) — ciclo de sueño de higiene autónomo
• think(last_cycle_only=True) — leer el último resumen del ciclo sin ejecutarlo
• stats(action="audit_leak") — auditoría de privacidad / candidatos a fugas
• stats(action="skill_outcomes") — recuento duradero de resultados de habilidades
• graph(action="auto_relate" / "record_link" / "record_unlink" / "linked_records" / "recall_with_links") — bordes de co-ocurrencia + enlaces registro-a-registro + recuerdo expandido por enlaces
• conflict(action="auto_resolve") — eliminar conflictos inequívocos de una sola pasada
• memory(action="chain_head" / "history") — cabeza de espacio de nombres de cadena + historial de revisiones
• trigger(action="prune") — limitar el backlog de disparadores pendientes
• remember(summary=...) — modo borrador: el motor atomiza un resumen largo en hechos semánticos enlazados (captura automática al final de la sesión)

Consulta yantrikdb.com/guides/mcp para la documentación completa.

Sustrato de habilidades (v0.8.0+)

YantrikDB expone un catálogo estructurado de habilidades para agentes, separado de los recuerdos sueltos de procedure. Las habilidades tienen un esquema (skill_id, applies_to, triggers, body, type) y se almacenan en el espacio de nombres dedicado skill_substrate, de modo que múltiples consumidores (este MCP, yantrikdb-hermes-plugin, el SDK de Lane B, WisePick, los endpoints /v1/skills/* de yantrikdb-server) lean y escriban el mismo sustrato. Antecedentes: Sarkar 2026 — Skill as Memory, Not Document.

Modelo de seguridad

Las escrituras de habilidades moldean el comportamiento futuro del agente entre sesiones, por lo que el servidor MCP implementa defensa en profundidad. Cada control tiene una perilla de variable de entorno (bloqueada al inicio — C2) y el estado completo se expone mediante stats(action="stats") y el registro de auditoría.

Controles en capas (cada uno viene activado por defecto salvo que se indique):

Capa	Control	Variable de entorno	Notas
Esquema	Regex de skill_id, cuerpo de 50–5000 caracteres, applies_to de 1–10 entradas, enum de skill_type	(siempre activo)	Mismo conjunto de regex que los /v1/skills/define de yantrikdb-server
A1 Marcadores de inyección de prompts	Rechaza cuerpos que contengan confusión de roles / patrones de "ignora instrucciones anteriores"	YANTRIKDB_SKILLS_DISABLE_SCANNERS=A1 para desactivar (auditado)	OWASP LLM01
A2 Escáner de credenciales	Claves de AWS/GitHub/Slack/Stripe/Google/Anthropic/OpenAI, claves privadas SSH/PGP, JWT, asignaciones de contraseñas	=A2 para desactivar	Subconjunto del escaneo de secretos de GitHub
A3 Bloqueo de URL/IP	Rechaza http(s), ftp, literales IPv4 en el cuerpo	YANTRIKDB_SKILLS_ALLOW_URLS=true para permitir	Ruta de exfiltración para agentes posteriores
A4 Evasión Unicode	Rechaza caracteres no imprimibles (Cf/Cs/Cn excepto los permitidos)	=A4 para desactivar	Anulación bidireccional (U+202E), espacios de ancho cero
A5 Carga útil codificada	Rechaza secuencias de ≥200 caracteres de base64/hex	=A5 para desactivar	Heurístico: propenso a falsos positivos para hashes grandes
B1 Lista de permitidos de espacios de nombres	El primer segmento de skill_id debe estar en la lista del operador	YANTRIKDB_SKILLS_ALLOWED_NAMESPACES=workflow,review	Sin definir = todo permitido
B2 Atribución de autor	Registra session_id, os_user, hostname, wall_clock, audit_nonce	(siempre activo)	Rastro forense
B3 Reemplazo entre orígenes	Se niega a sobrescribir una habilidad escrita por otro consumidor	YANTRIKDB_SKILLS_ALLOW_CROSS_ORIGIN_REPLACE=true para permitir	Defiende contra colisiones MCP↔hermes-plugin
B4 Integridad de supersesión	supersedes debe referenciar una habilidad existente en el mismo espacio de nombres	(siempre activo)	Bloquea el retiro malicioso de habilidades legítimas
C1 Compuerta limitada por tiempo	La compuerta se cierra automáticamente en la marca de tiempo (aplica tanto a definir como a resultado)	YANTRIKDB_SKILLS_WRITE_EXPIRES_AT=2026-12-31T00:00:00Z	Sin definir = sin caducidad
C1.5 Compuerta de resultado dividida	La acción de outcome usa su propia compuerta, activada por defecto	YANTRIKDB_OUTCOMES_WRITE_ENABLED=false para bloquear también los resultados	v0.8.1+: define y outcome tienen perfiles de amenaza diferentes: el resultado no puede introducir nuevas instrucciones, solo añadir {succeeded, note≤500} contra una habilidad existente. El bucle de retroalimentación funciona por defecto; bloquéalo explícitamente si es necesario
C2 Configuración bloqueada	Todas las variables de entorno de YANTRIKDB_SKILLS_* / YANTRIKDB_OUTCOMES_* se leen una vez al inicio	(siempre activo)	Mutar el entorno en un subproceso no puede eludir la compuerta
D1 Registro de auditoría	Anexo JSONL de cada evento de aceptación/rechazo/manipulación	YANTRIKDB_SKILLS_AUDIT_LOG=/var/log/yantrikdb/skills.jsonl	Sin definir = sin auditoría (advierte al arrancar)
D2 Límite de tasa	Tope de escritura por ventana deslizante por ID de sesión	YANTRIKDB_SKILLS_WRITE_RATE=30 (escrituras/min por defecto)	Derrota ataques de inundación
D3 Guardas de Outcome.note	Nota ≤500 caracteres + escaneada por A1/A2/A4	(siempre activo)	Cierra el canal lateral de resultados
D4 Contadores en stats	Conteos de aceptación/rechazo por motivo, expuestos en stats(action="stats")["skill_substrate"]	(siempre activo)	Paneles de operadores
E1 SHA-256 del cuerpo	Almacenado al escribir, re-verificado en cada lectura	(siempre activo)	Detecta manipulación de la base de datos fuera de banda: surface/get omiten discrepancias y registran en auditoría
E2 Origen del autor	Etiqueta metadata.author_origin — por defecto yantrikdb-mcp	YANTRIKDB_SKILLS_AUTHOR_ORIGIN=... para anular	Rastrea la procedencia del sustrato entre consumidores
F Seguridad de arranque	Advertencias al inicio sobre configuraciones peligrosas	(siempre activo)	Registra [F.1]–[F.5] en stderr + auditoría
G Cola de revisión para rule	Las habilidades de tipo rule se enrutan a skill_pending_review (no expuestas por surface/get/list)	YANTRIKDB_SKILLS_RULE_REQUIRES_REVIEW=false para desactivar (no recomendado)	Las reglas influyen en la política del agente: se requiere aprobación humana
Guardia multiinquilino	Advertencia de [F.1] si la base de datos muestra múltiples IDs de actor sin acuse	YANTRIKDB_SKILLS_MULTITENANT_ACK=true	Una base de datos = un inquilino es el valor predeterminado seguro

Lista de verificación 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.

El registro de auditoría es el registro canónico. Cada aceptación, cada rechazo (con el escáner que lo marcó), cada detección de manipulación en lectura, cada compuerta cerrada por caducidad — todo está ahí en JSONL. Conéctalo a tu SIEM.

Salida de ejemplo de stats(action="stats") (segmento 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 al momento de escribir)

Campo	Restricción
skill_id	Segmentos en minúsculas separados por puntos, longitud 4–200, p. ej. workflow.git.commit_clean
body	50–5000 caracteres
applies_to	1–10 identificadores en minúsculas con guion bajo (sin guiones — esencial para la consistencia del sustrato)
skill_type	Uno de procedure, reference, lesson, pattern, rule
on_conflict	reject (por defecto) o replace

Sesión de ejemplo

# 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")

Los resultados son eventos de solo anexión en el espacio de nombres outcome_substrate — sin consolidación automática en la habilidad principal, siguiendo la regla de diseño "esquema, no semántica" de yantrikdb-server. Los agentes (o el operador) pueden agregar resultados por sí mismos para calcular tasas de éxito.

Preguntas frecuentes

¿Qué es YantrikDB MCP?

YantrikDB MCP es un servidor de Protocolo de Contexto de Modelo (MCP) que brinda a los agentes de IA memoria cognitiva persistente entre sesiones. Expone 20 herramientas (remember, recall, forget, correct, think, graph, conflict, trigger, session, temporal, procedure, category, personality, stats, memory, skill, gaps, conversation, task, atlas) que cualquier cliente compatible con MCP — Claude Code, Cursor, Windsurf, Continue, Claude Desktop — puede llamar automáticamente sin necesidad de prompts.

¿En qué se diferencia de la memoria basada en archivos como CLAUDE.md?

La memoria basada en archivos carga todo en el contexto en cada conversación, lo que escala O(n) en costo de tokens. YantrikDB usa recuperación semántica selectiva — con 5,000 recuerdos, el enfoque basado en archivos cuesta ~101K tokens por conversación mientras que YantrikDB cuesta ~53 tokens. La precisión mejora con más datos en lugar de degradarse a medida que se llena la ventana de contexto. Script de referencia: python benchmarks/bench_token_savings.py.

¿Cómo se compara con mem0 / Letta / Zep / memoria MCP nativa?

Consulta la tabla comparativa a continuación. Versión corta: YantrikDB es el único que se distribuye tanto como motor Rust incrustable y servidor MCP y base de datos de red con la misma semántica de sustrato. Es el único con memoria procedimental de primera clase + un sustrato de habilidades validado por esquema al escribir + consolidación autónoma/detección de conflictos. También es el único cuyo motor subyacente se publica como artículo revisado por pares (Sarkar 2026, Zenodo DOI 10.5281/zenodo.20128887).

¿Puedo autoalojarlo?

Sí — de tres maneras. (1) Local: solo pip install yantrikdb-mcp y apunta tu cliente MCP hacia él. SQLite vive en ~/.yantrikdb/memory.db. (2) Red: ejecuta yantrikdb-server como un clúster HTTP multiinquilino, apunta el MCP hacia él mediante YANTRIKDB_SERVER_URL. (3) Híbrido: modo servidor SSE (yantrikdb-mcp --transport sse) para implementaciones compartidas.

¿Se envía mi data a algún lugar?

No. Todos los datos permanecen en tu máquina (o tu clúster). Sin telemetría, sin servicios de terceros. El incrustador predeterminado se ejecuta completamente en el motor Rust mediante búsqueda estática — sin descargas de modelos ni llamadas a API. Los incrustadores opcionales [onnx] y multilingües descargan los pesos del modelo una vez desde el CDN de HuggingFace y se ejecutan localmente a partir de entonces.

¿Cuál es la diferencia entre procedure y skill?

procedure almacena recuerdos sueltos de cómo hacer (clasificados por efectividad, sin esquema). skill almacena entradas de catálogo estructuradas (skill_id, applies_to, triggers, body, type) en un espacio de nombres dedicado skill_substrate compartido con yantrikdb-hermes-plugin, el SDK de Lane B, WisePick y los endpoints /v1/skills/* de yantrikdb-server. Usa procedure para notas personales de cómo hacer; usa skill para capacidades estructuradas de agentes que otros consumidores deberían poder exponer.

¿Es seguro habilitar la autoría de habilidades?

Las escrituras de habilidades están desactivadas por defecto precisamente porque pueden moldear el comportamiento futuro del agente. Cuando activas la compuerta, se aplican siete capas de defensa en profundidad: escáner de inyección de prompts, escáner de credenciales, bloqueo de URL, escáner de evasión Unicode, lista de permitidos de espacios de nombres, atribución de autor, registro de auditoría, límite de tasa, detección de manipulación por hash del cuerpo y una cola de revisión para habilidades de tipo rule. Consulta el Modelo de seguridad arriba.

¿Funciona en producción?

Sí — yantrikdb-mcp se ejecuta en producción en el clúster homelab de YantrikDB (1973+ recuerdos, transporte SSE, 2 semanas de tiempo de actividad por ciclo de lanzamiento) y es la implementación de referencia detrás de las decisiones de lanzamiento del motor. v0.8.x agregó la cadencia de parches del mismo día del motor al propio servidor MCP: los problemas externos presentados por colaboradores de la comunidad se convierten en correcciones publicadas en menos de 2 horas.

¿En qué está escrito el motor?

El motor de YantrikDB es Rust (crates.io: yantrikdb) con enlaces Python pyo3 (PyPI: yantrikdb). El servidor MCP en sí es Python — un envoltorio delgado alrededor de los enlaces Python del motor, más el transporte stdio/SSE/HTTP.

Comparación con otros sistemas de memoria para agentes

Capacidad	YantrikDB MCP	mem0	Letta (MemGPT)	Zep	Memoria MCP nativa de sistema de archivos
Nativo MCP	✅ de primera clase	mediante integración personalizada	mediante integración personalizada	mediante integración personalizada	✅ con forma de sistema de archivos
Incrustable (sin servidor)	✅ Rust + Python	❌ requiere servicio	❌ requiere servicio	❌ requiere servicio	✅ sistema de archivos
Modo base de datos de red	✅ clúster HA Raft	✅ Pro / Enterprise	✅ autoalojado	✅ gestionado + autoalojado	❌
Recuperación semántica (vector)	✅ HNSW	✅	✅	✅	❌ (solo grep de archivos)
Grafo de conocimiento	✅ nodos + aristas tipados	✅ (adición reciente)	parcial	✅	❌
Detección de contradicciones	✅ autónoma	❌	❌	❌	❌
Memoria procedimental	✅ clasificada por efectividad	❌	parcial	❌	❌
Sustrato de habilidades (validado por esquema)	✅ con 7 capas de defensa	❌	❌	❌	❌
Consolidación autónoma (think)	✅	❌	parcial	✅	❌
Decaimiento temporal + vida media	✅ modelo biológico	❌	❌	❌	❌
Disparadores proactivos	✅	❌	❌	❌	❌
Derivación de rasgos de personalidad	✅ a partir de patrones de memoria	❌	❌	❌	❌
Almacenamiento	SQLite local + WAL	alojado	local	local + alojado	sistema de archivos
Licencia	MIT (motor Apache-2.0)	Apache 2.0	Apache 2.0	Apache 2.0	MIT
Artículo revisado por pares	✅ Zenodo	❌	✅ artículo MemGPT	❌	❌
Cadencia de parches del mismo día para problemas	✅ (promedio <2h en v0.8.x)	varía	varía	varía	n/a

Las comparaciones reflejan capacidades públicas a mayo de 2026. Se aceptan PRs para corregir cualquier fila.

Cita este trabajo

Si usas YantrikDB en un contexto académico o de investigación, cita el artículo del sustrato:

@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 en texto plano:

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

Ejemplos

1. Recuperación automática al inicio de la conversación

Usuario: "¿Qué decidimos sobre la migración de la base de datos?" El agente llama automáticamente a recall("database migration decision") y recupera recuerdos relevantes antes de responder, sin necesidad de indicaciones manuales.

2. Recordar decisiones + construir grafo de conocimiento

Usuario: "Vamos a usar PostgreSQL para el nuevo servicio. Alice será la responsable de la migración."

El agente llama a:

• 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. Detección de contradicciones

Después de almacenar "Usamos Python 3.11" y más tarde "Actualizamos a Python 3.12", llamar a think() detecta el conflicto. El agente lo muestra:

"He encontrado una contradicción: anteriormente dijiste Python 3.11, pero recientemente mencionaste Python 3.12. ¿Cuál es la versión actual?"

Luego lo resuelve con conflict(action="resolve", conflict_id="...", strategy="keep_b").

Política de privacidad

El servidor MCP de YantrikDB almacena todos los datos localmente en tu máquina (por defecto: ~/.yantrikdb/memory.db). No se envían datos a servidores externos, no se recopila telemetría y no se contacta con servicios de terceros durante la operación.

• Recopilación de datos: Solo lo que almacenas explícitamente mediante la herramienta remember o lo que el agente de IA almacena en tu nombre.
• Almacenamiento de datos: Base de datos SQLite local en tu sistema de archivos. Controlas la ruta mediante YANTRIKDB_DB_PATH.
• Compartición con terceros: Ninguna. Los datos nunca salen de tu máquina en modo local (stdio).
• Modo red: Al usar transporte SSE/HTTP, los datos viajan entre tu cliente y tu servidor autoalojado. No intervienen servidores de Anthropic ni de terceros.
• Modelo de incrustación: Utiliza un modelo ONNX local (all-MiniLM-L6-v2). Los archivos del modelo se descargan una vez desde Hugging Face Hub en el primer uso y luego se almacenan en caché localmente.
• Retención: Los datos persisten hasta que los elimines (herramienta forget) o borres el archivo de la base de datos.
• Contacto: developer@pranab.co.in

Política completa: yantrikdb.com/privacy

Contribuciones

Consulta CONTRIBUTING.md para la configuración del entorno virtual, ejecutar pytest y abrir solicitudes de extracción (PRs).

Soporte

• Problemas: github.com/yantrikos/yantrikdb-mcp/issues
• Correo electrónico: developer@pranab.co.in
• Documentación: yantrikdb.com/guides/mcp

Proyectos relacionados

Mismo sustrato de memoria, diferentes puntos de entrada:

• yantrikdb — el motor Rust/Python incrustable sobre el que se ejecuta este servidor (pip install yantrikdb).
• yantrikdb-server — puerta de enlace HTTP y clúster de alta disponibilidad, para los modos de despliegue en red anteriores.
• yantrikdb-client — cliente Python tipado para ese servidor.
• langchain-yantrikdb — YantrikDB como VectorStore y ChatMessageHistory de LangChain.
• yantrikdb-hermes-plugin — proveedor de memoria para NousResearch/hermes-agent, que comparte el mismo sustrato de habilidades.
• yantrik-memory — capa de memoria independiente del framework con rasgos y evolución de vínculos.

Licencia

Este servidor MCP está licenciado bajo MIT — úsalo libremente en cualquier proyecto.

Nota: Este paquete depende de yantrikdb (el motor de memoria cognitiva), que está licenciado bajo Apache-2.0 a partir del 18-08-2026 (anteriormente AGPL-3.0). Tanto este servidor como el motor ahora tienen licencias permisivas: no hay obligaciones de copyleft sobre tu código, modificaciones o servicios alojados.