GENOME

GENOME

Memoria abierta para agentes de IA. La misma precisión de respuestas que Mem0, pero ~1.000× más barata de almacenar, funciona completamente sin conexión y mantiene un registro auditable.

Artículo: ¿Necesitan los agentes un LLM para recordar? Una evaluación de la ingesta de memoria sin LLM (preprint, 2026): la evaluación completa detrás de los números siguientes, incluidos los resultados negativos. El PDF también está en papers/.

La mayoría de las herramientas de memoria para agentes (como Mem0) llaman a un LLM en cada mensaje para decidir qué recordar. Esa es la parte lenta y costosa, y la apuesta de GENOME es que no la necesitas. GENOME simplemente incrusta cada mensaje localmente: sin LLM, sin API, sin red en la ruta de escritura.

Evaluado honestamente con conjuntos de datos públicos (LoCoMo, LongMemEval), GENOME responde con la misma precisión que Mem0, mientras almacena recuerdos por una fracción del costo y funciona completamente sin conexión.

Transparencia desde el principio: en precisión de respuestas, GENOME empata con Mem0; no afirmamos superarlo en ese aspecto (dos ejecuciones independientes de benchmarks confirman la paridad). La ventaja está en el costo, la velocidad, el funcionamiento sin conexión y un registro temporal/auditable que Mem0 no puede producir.

¿No lo crees? Compruébalo tú mismo

Las afirmaciones de costo, velocidad y funcionamiento sin conexión no requieren clave de API: mídelas en tu máquina en 60 segundos:

git clone https://github.com/NORTHTEKDevs/genome && cd genome
pip install -e . && python -m genome.verify

Escribe recuerdos con tu red de salida físicamente bloqueada e imprime un recibo de aprobación/fallo en vivo: 0 llamadas de red, 0 llamadas a LLM, escrituras de un solo dígito en ms, recuperación que funciona:

  [PASS] Air-gapped write path: wrote 200 memories with every outbound socket blocked -> 0 network attempts, 0 LLM calls
  [PASS] Write latency: 7.1 ms/message  (Mem0's measured write path: ~2,055 ms + 1 LLM call/message)
  [PASS] Retrieval works: top hit score 0.598

Ese recibo cubre solo la historia de costo/velocidad/sin conexión. La afirmación de paridad de precisión con Mem0 es una verificación separada y más amplia que necesita una clave de LLM: reprodúcela cara a cara con las mismas preguntas con tu propia clave mediante python benchmarks/head_to_head.py (una clave de OpenRouter funciona; consulta benchmarks/RESULTS.md para las ejecuciones n=90 / n=205, las pruebas de significancia pareadas y los nulos publicados). La suite de pruebas completa se ejecuta en CI público (insignia arriba). La propuesta no es "confía en mí", es "ejecútalo".

Añade memoria persistente a tu agente en una línea (MCP)

GENOME incluye un servidor MCP totalmente local: memoria entre sesiones para Claude Desktop, Claude Code o Cursor sin clave de API y sin que los datos salgan de tu máquina:

pip install "genome-memory[mcp]"

{ "mcpServers": { "genome": { "command": "genome-mcp" } } }

O instalación sin pasos adicionales mediante uv: { "command": "uvx", "args": ["--from", "genome-memory[mcp]", "genome-mcp"] }

Herramientas que recibe el agente: remember, recall, forget, reset_memories. Los recuerdos persisten localmente en ~/.genome/memories.db. Detalles completos de MCP ↓

GENOME vs Mem0 de un vistazo

	GENOME	Mem0
Precisión de respuestas (LoCoMo, LongMemEval)	empate	empate
Llamadas a LLM para almacenar un mensaje	0	1+
Velocidad de escritura	~10 ms	~2.000 ms
Funciona sin conexión / aislado	sí	no (necesita una API de LLM)
Costo de ingesta (despliegue de 10k usuarios)	~$190 / año	$159k-$1,6M / año
"¿Qué era verdad en marzo?" (punto en el tiempo)	sí	no
Memoria determinista y auditable	sí	no

Cada número se mide dentro de un mismo entorno: mismo respondedor, juez, incrustador y top-k; solo cambia la capa de memoria, con pruebas de significancia pareadas. Detalle completo y procedencia de cada número: benchmarks/RESULTS.md. Informe formateado: benchmarks/GENOME-LoCoMo-Report.pdf.

Por qué es ~1.000× más barato: nunca llama a un LLM para recordar

Almacenar un mensaje cuesta una llamada a LLM en Mem0, cero en GENOME (solo una incrustación local). Eso no es un benchmark que puedas discutir: es aritmética, y se mantiene sin importar con qué LLM lo compares en precio. Con 10.000 usuarios × 50 mensajes/día (15M de mensajes/mes):

Modelo que Mem0 usa para extraer	Factura anual de ingesta de Mem0	GENOME
Claude Haiku	$1.601.757	$190
gpt-4o-mini	$238.596	$190
modelo alojado más barato	$159.064	$190

La brecha sobrevive al modelo más barato y crece en producción (Mem0 reenvía los recuerdos almacenados al LLM a medida que el almacén se llena). Reproduce: python benchmarks/tco_project.py (sin clave de API).

Funciona aislado

El incrustador predeterminado de GENOME es local. Demostramos que la ruta de escritura es genuinamente sin conexión al bloquear toda la red durante las escrituras: aun así tienen éxito:

• ~10 ms/mensaje, 0 llamadas de red, 0 llamadas a LLM (python benchmarks/local_writepath.py)
• Mem0 no puede hacer esto: necesita una llamada a una API de LLM para ingerir.

Eso hace que GENOME sea utilizable en instalaciones locales, entornos regulados o completamente sin conexión. Es una capacidad de sí/no, no un punto de precio.

Cómo funciona

• Escritura: incrusta el mensaje localmente y almacénalo. Sin LLM, sin red. (~10 ms)
• Lectura: búsqueda vectorial sobre tus recuerdos, con un reordenador de codificador cruzado local opcional para consultas más difíciles.
• Capa bi-temporal opcional: rastrea cómo cambian los hechos con el tiempo y responde "¿qué era verdad en el tiempo T?" — ver más abajo.

Instalación

pip install genome-memory

El incrustador predeterminado es local (sentence-transformers/all-MiniLM-L6-v2): sin clave de API, funciona sin conexión; la primera ejecución descarga el modelo de ~90 MB una vez. Las incrustaciones de OpenAI son opcionales para una recuperación de mayor dimensionalidad.

Huella de dependencias, honestamente: la instalación principal es numpy, sentence-transformers, scikit-learn y rank-bm25. Las incrustaciones locales se ejecutan en PyTorch (incorporado por sentence-transformers), así que no es una instalación pequeña: ese es el intercambio deliberado por incrustación sin conexión y de costo cero. Las dependencias de gráficos/benchmarks viven en un extra opcional [viz], no en el núcleo. ¿Migrando desde Mem0? Consulta docs/migrating_from_mem0.md.

Inicio rápido (totalmente local, sin clave de API)

from genome import Memory

mem = Memory(storage="genome.db")   # local embedder by default; ":memory:" for ephemeral

# Store a message -- embedded locally, no LLM call, no network
mem.add("Ada met Lin at the robotics summit in Berlin.", user_id="u1")
mem.add("They are collaborating on an open-source planning library.", user_id="u1")

# Retrieve the most relevant memories
for hit in mem.search("Where did Ada meet Lin?", user_id="u1", limit=5):
    print(f"{hit.score:.3f}  {hit.content}")

Memory refleja la API de Mem0 (add / search / get / delete / reset): un reemplazo casi directo. Para usar incrustaciones de OpenAI en su lugar (establece OPENAI_API_KEY):

from genome import Memory, EmbeddingProvider
mem = Memory(storage="genome.db",
             embedding_provider=EmbeddingProvider(model_name="openai:text-embedding-3-small"))

Úsalo como servidor MCP (memoria totalmente local para cualquier agente)

GENOME incluye un servidor MCP, por lo que cualquier cliente MCP (Claude Desktop, Claude Code, Cursor, ...) obtiene memoria persistente entre sesiones que se ejecuta enteramente en la máquina local: sin llamadas a LLM, sin claves de API, sin que los datos salgan del equipo. La mayoría de los MCP de memoria no pueden decir eso.

Instala con el extra mcp y luego agrégalo a la configuración de tu cliente:

pip install "genome-memory[mcp]"

{
  "mcpServers": {
    "genome": { "command": "genome-mcp" }
  }
}

Herramientas que recibe el agente: remember (almacena un hecho/preferencia, local + 0 LLM), recall (búsqueda semántica), forget (elimina la memoria que coincide con una consulta), reset_memories (limpia los recuerdos de un usuario). Los recuerdos persisten en ~/.genome/memories.db (anula con la variable de entorno GENOME_MCP_DB). Ejecuta de forma independiente con genome-mcp o python -m genome.mcp.server.

Ejecútalo como API HTTP

¿Prefieres HTTP? GENOME incluye un servidor FastAPI que refleja la biblioteca 1:1 (add / search / get / update / delete / reset / synthesize), con una especificación OpenAPI autogenerada en /docs.

pip install "genome-memory[fastapi]"

Pruébalo localmente (sin clave, solo loopback: una bandera hace explícita la intención de "sin autenticación"):

GENOME_ALLOW_NO_AUTH=1 python -m genome.server        # serves on 127.0.0.1:8080

curl -X POST localhost:8080/v1/memories \
  -H 'Content-Type: application/json' \
  -d '{"text": "Ada met Lin at the robotics summit in Berlin.", "user_id": "u1"}'

curl -X POST localhost:8080/v1/search \
  -H 'Content-Type: application/json' \
  -d '{"query": "Where did Ada meet Lin?", "user_id": "u1", "limit": 5}'

Seguro por defecto. El servidor se niega a servir sin autenticación a menos que optes por ello como arriba, y no vinculará una interfaz que no sea loopback sin una clave. Para exponerlo, establece una clave de API (enviada como X-API-Key): requerida para vincular más allá de localhost:

GENOME_API_KEY=$(openssl rand -hex 32) GENOME_HOST=0.0.0.0 python -m genome.server
# then add:  -H "X-API-Key: $GENOME_API_KEY"  to every request

Para despliegues multiinquilino, establece GENOME_REQUIRE_SCOPE=1 para requerir user_id/agent_id en cada llamada y deshabilita el reinicio global. Docker: docker-compose up (necesita GENOME_API_KEY y POSTGRES_PASSWORD; Postgres se publica solo en loopback). Guía completa, incluido el backend de Postgres y cada variable de entorno: docs/tutorial_quickstart.md.

Cliente TypeScript / JavaScript

@northtek/genome-memory refleja la forma de la API de Python Memory contra este servidor (ESM, Node 20+ o navegador):

npm install @northtek/genome-memory

import { Memory } from "@northtek/genome-memory";

const mem = new Memory({ baseUrl: "http://localhost:8080" });
await mem.add({ text: "Ada met Lin in Berlin.", userId: "u1" });
const hits = await mem.search({ query: "Where did Ada meet Lin?", userId: "u1" });

Documentación completa del cliente: sdks/typescript/README.md.

Los resultados honestos

Mismo respondedor + juez + incrustador para cada sistema; solo cambia la capa de memoria.

Lo que medimos	Resultado	Veredicto
Precisión de respuestas, dentro de ventana (LoCoMo)	GENOME 0,851 vs Mem0 0,855 (p > 0,23)	Empate
Precisión de respuestas, benchmark más difícil (LongMemEval, n=90 y n=205)	direccionalmente por delante, no significativo (p = 0,14-0,19)	Empate
Precisión cuando el historial desborda la ventana de contexto	+0,409 con 80× menos contexto (p = 8e-10)	Victoria
Costo de almacenar un mensaje	0 llamadas a LLM vs 1+; 837-8.433× más barato	Victoria
Ruta de escritura	~10 ms, aislado, 0 llamadas de red	Victoria
Punto en el tiempo ("¿qué era verdad en T?")	estado de creencia 0,870 vs Mem0 0,676 (datos sintéticos)	Victoria, con advertencia
Tasa de aciertos de recuperación con reordenamiento	mejora hit@10 (hasta 0,943); local y gratuito	Victoria

Lo que probamos que no ayudó (para que no tengas que hacerlo)

Publicamos nuestros nulos: así sabes que las victorias son reales:

• Síntesis / consolidación: neutral en precisión con presupuesto de tokens igual (p = 0,86).
• Recuperación híbrida (BM25 + densa) y por grafo: la híbrida rindió por debajo de la densa simple en LoCoMo; el grafo no se validó aquí.
• La ganancia de precisión del reordenamiento depende del incrustador: mejora de manera confiable la tasa de aciertos de recuperación, pero su efecto en la precisión final de respuestas depende del incrustador: trátalo como una herramienta de calidad de recuperación, no como una victoria garantizada de precisión.

Memoria bi-temporal: "¿qué era verdad en el tiempo T?"

GENOME puede rastrear cómo cambian los hechos con el tiempo y responder preguntas de punto en el tiempo: algo que la memoria basada en sobrescritura estructuralmente no puede hacer (solo conserva el valor más reciente):

from genome.memory.belief import ingest_belief_turn, answer_belief_context

mem = Memory(storage="genome.db", llm_call=my_llm_fn)

# facts land at their DOMAIN time (parsed from the text), not wall-clock ingest time
ingest_belief_turn(mem, "In March 2024, Jordan moved to Seattle.", session_time=t0, user_id="u")
ingest_belief_turn(mem, "Jordan just moved to Austin.", session_time=t2, user_id="u")

answer_belief_context(mem, "Where does Jordan live now?", user_id="u")            # -> Austin
answer_belief_context(mem, "Where did Jordan live in early 2024?", user_id="u")   # -> Seattle
answer_belief_context(mem, "List every city Jordan has lived in.", user_id="u")   # -> Seattle; Austin

En el benchmark TempBelief responde consultas "a fecha de" con 0,870 frente al 0,676 de Mem0, con el grafo de conocimiento auditado con 0,97 de precisión / 0,96 de recuperación. Advertencia: TempBelief es texto sintético con fechas explícitas; la ventaja se reduce en el habla natural. Capacidad real, prueba acotada.

Funciones opcionales

Opt-in; la ruta predeterminada permanece sin LLM y local en la ingesta.

mem = Memory(
    storage="genome.db",
    llm_call=my_llm_fn,             # LLM-based fact extraction on add()
    resolve_conflicts=True,         # ADD/UPDATE/DELETE vs existing memories
    auto_extract_entities=True,     # entity graph for graph retrieval
    auto_consolidate_threshold=200, # summarize-or-prune when a scope grows past N
)
mem.search("...", user_id="u1", mode="hybrid")   # modes: "dense" (default), "hybrid", "graph"

Reordenamiento (local, gratuito, sin API):

from genome.memory.rerank import CrossEncoderReranker
mem = Memory(storage="genome.db", reranker=CrossEncoderReranker())   # lazy-loaded
mem.search("Where did the user go on vacation?", user_id="u1", limit=5)  # reranked

Reproduce los benchmarks

Los conjuntos de datos LoCoMo y LongMemEval no están incluidos (tienen sus propias licencias: LoCoMo es CC BY-NC 4.0). Consulta benchmarks/data/README.md para descargarlos. Las dos primeras líneas no necesitan conjunto de datos ni claves de API:

python benchmarks/local_writepath.py        # local write path: ~10ms/msg, 0 network
python benchmarks/tco_project.py            # deployment cost projection
python benchmarks/verdict.py                # in-window accuracy + McNemar
python benchmarks/haystack_report.py        # overflow / context-window crossover
python benchmarks/ingest_cost.py --n 80     # measured ingestion cost vs Mem0
python benchmarks/lme_qa.py --n 90          # LongMemEval head-to-head vs Mem0
python benchmarks/tempbelief_run.py --convs 6   # bi-temporal point-in-time vs baselines

Soporte y nivel comercial

Errores y preguntas: issues y discussions. El soporte comunitario es de mejor esfuerzo: consulta SUPPORT.md.

GENOME Enterprise es un producto comercial separado para compradores regulados y de instalaciones locales que deben responder ante un auditor sobre qué sabía un sistema de IA y cuándo: un registro de auditoría encadenado por hash a prueba de manipulaciones, reconstrucción de punto en el tiempo, informes de cumplimiento, retención con pruebas de borrado, RBAC y SSO. Autoalojado y con licencia por despliegue: no hay versión alojada, deliberadamente, porque el valor es que tus datos nunca salen. Ese nivel es lo que financia este. ¿Evaluarlo o quieres soporte comercial sobre el núcleo abierto? info@northtek.io

Licencia

Licencia Apache 2.0: consulta LICENSE y NOTICE.

GENOME es gratuito y de código abierto: léelo, modifícalo, autoalójalo e intégralo en tus propias aplicaciones, incluido el uso comercial, bajo los términos de Apache 2.0. No hay un "cebo y cambio de núcleo abierto" planeado: el núcleo permanece bajo Apache-2.0.

La concesión de Apache-2.0 cubre el código, no el nombre: consulta TRADEMARKS.md, que comienza con lo que puedes hacer sin pedir permiso. Preguntas: info@northtek.io.

Copyright 2026 Northtek (FrostByte Digital LLC). mcp-name: io.github.NORTHTEKDevs/genome