StudioMeyer local memory

Parte del StudioMeyer MCP Stack — Hecho en Mallorca 🌴 · ⭐ si lo usas

local-memory-mcp

**Memoria local persistente para Claude, Cursor y Codex. 25 herramientas. Recuperación híbrida (BM25 + coseno vectorial, RRF). Consultas bi-temporales asOf + sustitución de hechos. Detección de contradicciones sin LLM + reflexión. Exportación/importación JSON portátil. Embeddings multilingües. Sin nube. Sin claves API.**

Tu asistente de IA lo olvida todo cuando cierras el chat. Esto lo soluciona.

Aprendizajes, decisiones, personas, proyectos — almacenados en un único archivo SQLite en tu máquina que nunca sale de tu ordenador. Grafo de conocimiento integrado, detección de duplicados, búsqueda por palabras clave FTS5 y (nuevo en v2) recuperación híbrida que fusiona BM25 con coseno vectorial local mediante fusión de rango recíproco. El modelo de embeddings es multilingüe (DE / EN / ES / más de 100 idiomas) y se ejecuta localmente — sin claves API, sin nube.

📄 Análisis profundo: WHITEPAPER.md — arquitectura, principios de diseño, el contrato local-first y una comparación honesta con otros sistemas de memoria.

No está afiliado con danieleugenewilliams/local-memory-releases — ese es un proyecto diferente de "Local Memory" con el mismo nombre descriptivo. Este paquete se publica como @studiomeyer/local-memory-mcp — usa siempre el nombre con ámbito para desambiguar.

Una nota nuestra

Hemos estado construyendo herramientas y sistemas para nosotros mismos durante los últimos dos años. El hecho de que este repositorio sea pequeño y tenga pocas estrellas no es porque sea nuevo. Es porque solo ahora hemos decidido compartir lo que hemos construido. No es un experimento reciente, es una historia larga con un commit reciente.

Nos encanta construir cosas y compartirlas. No nos gustan las tácticas de redes sociales, los trucos de crecimiento ni perseguir estrellas y seguidores. Así que este repositorio es pequeño. El código es real, se usa, las incidencias se responden. Juzga por ti mismo.

Si te ayuda, compartir, probar y dar feedback nos ayuda. Si podría ser mejor, una incidencia es más útil. Si construyes algo con ello, escríbenos a hello@studiomeyer.io. Eso realmente alegra nuestro día.

Desde un pequeño estudio en Palma de Mallorca.

Inicio rápido

Claude Code

claude mcp add memory -- npx -y @studiomeyer/local-memory-mcp

Claude Desktop

Lo más fácil: paquete MCPB de un clic. v2.0.0 incluye paquetes .mcpb precompilados para cada plataforma de escritorio principal — descarga el de tu sistema operativo desde la última versión y haz doble clic. Claude Desktop te guía en la instalación — sin editar JSON, sin npm install, sin terminal.

Plataforma	Paquete
Linux x64	local-memory-mcp-2.2.0-linux-x64.mcpb
macOS Apple Silicon	local-memory-mcp-2.2.0-darwin-arm64.mcpb
macOS Intel	local-memory-mcp-2.2.0-darwin-x64.mcpb
Windows x64	local-memory-mcp-2.2.0-win32-x64.mcpb

Cada paquete es específico de la plataforma porque better-sqlite3 es un módulo nativo — el binario .node correspondiente se incluye dentro del paquete para que no necesites una cadena de herramientas de compilación.

Configuración manual (todas las plataformas — añade a claude_desktop_config.json, consulta Configuración > Desarrollador > Editar configuración):

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@studiomeyer/local-memory-mcp"]
    }
  }
}

Cursor / VS Code

Añade a .cursor/mcp.json o .vscode/mcp.json:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@studiomeyer/local-memory-mcp"]
    }
  }
}

Codex

# ~/.codex/config.toml
[mcp_servers.memory]
command = "npx"
args = ["-y", "@studiomeyer/local-memory-mcp"]

Seguimiento automático de sesiones

Puedes hacer que el seguimiento de sesiones sea totalmente automático para no tener que pensar en ello.

Claude Code (CLAUDE.md): Añade esta línea al CLAUDE.md de tu proyecto:

Always call memory_session_start at the beginning of each conversation and memory_session_end when done.

Claude Code (Hook): Para una configuración a nivel de sistema, añade un hook SessionStart en ~/.claude/settings.json:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "echo '{\"hookSpecificOutput\":{\"hookEventName\":\"SessionStart\",\"additionalContext\":\"Call memory_session_start now.\"}}'",
        "timeout": 5
      }]
    }]
  }
}

Ambos enfoques hacen que Claude llame a memory_session_start automáticamente. La forma con CLAUDE.md es más simple; la forma con hook funciona en todos los proyectos.

Qué hace

Cuando inicias una conversación, el servidor carga el contexto de tus últimas sesiones para que la IA sepa en qué estabas trabajando.

Durante la conversación, la IA almacena patrones, ideas y errores mediante memory_learn. Registra hechos sobre personas, proyectos y herramientas mediante memory_entity_observe — construyendo un grafo de conocimiento con el tiempo. Cada fila almacenada también se incrusta en un vector local de 384 dimensiones mediante el modelo multilingual-e5-small.

Cuando buscas, el memory_search unificado ejecuta recuperación híbrida: FTS5 con ranking BM25 se fusiona con coseno vectorial mediante fusión de rango recíproco (RRF, k=60). Esto supera los desajustes de vocabulario ("enviar" encuentra "publicar"), funciona en DE / EN / ES / más de 100 idiomas, y coincide incluso cuando la consulta no tiene solapamiento exacto de tokens con el contenido almacenado. Si la extensión vectorial no puede cargarse en tu máquina, la búsqueda vuelve de forma transparente a solo FTS5 — nada se rompe, solo pierdes la mitad semántica.

El guardián de duplicados sigue evitando que se almacene la misma información dos veces.

Búsqueda híbrida (v2.0.0+)

memory_search({ query: "...", mode: "hybrid" })   // default
memory_search({ query: "...", mode: "fts" })       // keyword only
memory_search({ query: "...", mode: "vector" })    // cosine only

Arquitectura

• search_fts (FTS5, BM25) — recuperación por palabras clave, la ruta v1.
• embeddings (tabla virtual sqlite-vec vec0, float[384]) — recuperación vectorial.
• La fusión de rango recíproco (k=60) combina ambos cuando mode: "hybrid".
• Los embeddings provienen de Xenova/multilingual-e5-small (Apache-2.0) mediante Transformers.js, cuantizados en q8 (~30 MB de caché). El modelo se carga de forma diferida en la primera llamada de embedding; se ejecuta completamente en CPU.
• Auto-embedding al insertar cubre aprendizajes, decisiones y observaciones de entidades. Las entidades en sí no se incrustan — sus observaciones adjuntas llevan la superficie semántica.

Multilingüe. El modelo predeterminado está entrenado en más de 100 idiomas con un fuerte rendimiento de recuperación en DE/EN/ES. Mezclar idiomas en tus datos almacenados está bien — consulta en un idioma y la mitad del coseno aún mostrará resultados relevantes en otro.

Anulaciones de entorno

• MEMORY_EMBED_DISABLED=1 — fuerza solo FTS5 (por ejemplo, redes aisladas o con proxy corporativo).
• MEMORY_EMBED_MODEL=... — cambia a un modelo diferente de extracción de características de Transformers.js.
• MEMORY_EMBED_CACHE_DIR=... — anula la ubicación de la caché de Transformers.js.
• MEMORY_EMBED_DTYPE=fp32|fp16|q8|q4 — cuantización del modelo (predeterminado q8).

Ciclo de vida + Reflexión (v2.1.0+)

v2.1 cierra la brecha entre "almacenar un hecho" y "gestionar una memoria a lo largo del tiempo". El esquema ha llevado archived, lifecycle_state, valid_from y valid_to desde v1, pero ninguna herramienta los exponía. Ahora cuatro herramientas lo hacen.

asOf bi-temporal — "¿qué sabía en la fecha X?"

memory_entity_open({ id: "...", asOf: "2026-04-15" })

Devuelve la entidad más el conjunto de observaciones cuya ventana de validez contenía 2026-04-15. El filtro es valid_from <= asOf AND (valid_to IS NULL OR valid_to > asOf). Acepta cualquier formato que datetime() de SQLite reconozca: ISO 8601 (2026-04-15T00:00:00Z), estilo SQLite (2026-04-15 00:00:00) o solo fecha (2026-04-15). Sin asOf obtienes la vista en vivo heredada (cada observación con valid_to IS NULL).

Decisión de diseño — solo tiempo válido, no bi-temporal completo. SQL:2011, XTDB, Datomic ofrecen bi-temporal de dos ejes (tiempo válido × tiempo de transacción). Hacemos solo tiempo válido; el tiempo de transacción vive pasivamente en created_at pero no es consultable como un eje separado. Para un producto de memoria local de IA, la pregunta es "¿qué sabía la IA sobre X en la fecha Y" — eso es tiempo válido. El bi-temporal completo importa para pistas de auditoría reguladas (seguros, banca) — si lo necesitas, recurre a XTDB.

Nota de escala. El predicado asOf envuelve valid_from en datetime() de SQLite para comparaciones robustas de formato, lo que significa que el planificador no puede usar un índice en la columna directamente. Para corpus de <1000 observaciones por entidad (típico), el escaneo es de submilisegundos. Si tienes una entidad con más de 10k observaciones, añade un índice de expresión — CREATE INDEX idx_obs_valid_from_dt ON entity_observations(datetime(valid_from)) — y el predicado vuelve a ser sargable.

Escáner de contradicciones — sin LLM

memory_contradictions({ minCosine: 0.75, minConfidenceDrift: 0.2 })
memory_contradictions({ entityId: "...", limit: 20 })

Muestra pares de observaciones que son semánticamente muy cercanas (similitud de coseno por encima de minCosine) pero que discrepan en:

• XOR de marcador de negación — un lado afirma, el otro niega (regex cubre EN / DE / ES / Catalán).
• Deriva de confianza — misma afirmación superficial, valores de confidence muy diferentes.

Sin LLM a propósito — la promesa de sin claves API se mantiene. La heurística es conservadora; el cliente de IA juzga. Los duplicados puros (sin negación, sin deriva de confianza) no se marcan. El cálculo de coseno se ejecuta en SQL mediante vec_distance_cosine, por lo que la extensión debe estar cargada; en plataformas donde no lo está, la herramienta devuelve VECTOR_DISABLED con un mensaje claro en lugar de degradarse silenciosamente.

Calibración. El minCosine = 0.75 predeterminado sigue la literatura de ajuste de recuperadores de 2026 (SparseCL en Arguana; guía de ajuste de umbral de Milvus) que encuentra un aumento pronunciado de falsos positivos por debajo de 0.7. Baja a 0.6 para uso centrado en recuperación, sube a 0.85 para uso centrado en precisión. La regex de negación cubre EN / DE / ES / Catalán / Portugués / Italiano / Francés — los siete idiomas que multilingual-e5-small maneja con más fuerza.

Sustituir — retirar un hecho obsoleto (v2.2)

memory_observation_supersede({ observationId: "..." })
memory_observation_supersede({ observationId: "...", supersededById: "..." })

El escáner encuentra un hecho obsoleto; memory_observation_supersede actúa sobre él. Establece el valid_to de la observación más antigua (una marca de tumba) para que el hecho deje de aparecer en memory_search y memory_entity_open en vivo — pero la fila permanece en la base de datos, por lo que una consulta asOf aún la devuelve como la creencia que era actual antes del corte. Este es el patrón de sustitución de hechos de Zep: invalidar, nunca eliminar. Pasa supersededById y el corte se convierte en el valid_from del hecho más nuevo (el hecho antiguo era verdadero justo hasta que se registró el nuevo); pasa validTo para un instante explícito, o ninguno para ahora. Los guardas de misma entidad y auto-sustitución mantienen la operación sensata, y una segunda llamada es idempotente (already_superseded).

Archivar + actualizar — ciclo de vida para aprendizajes

memory_learn_archive({ learningId: "...", reason: "wrong" })
memory_learn_update({ learningId: "...", content: "…", confidence: 0.9 })

archive es un borrado suave: la fila permanece en learnings (con archived = 1, archived_at y lifecycle_state = 'archived' | 'archived:<reason>'), el embedding permanece en vec0 (para que las referencias cruzadas estilo asOf aún puedan resolverse), pero recall / search / la verificación de duplicados lo filtran. Idempotente.

update edita un aprendizaje en vivo (no archivado). Si content cambia, re-incrustamos en el patrón atómico F4 (calcular fuera de la transacción, escribir dentro de un db.transaction() sincronizado). Si la escritura del embedding falla o vec está deshabilitado, el embedding antiguo ahora obsoleto se purga para que la búsqueda de coseno no pueda mostrar un vector que ya no representa el texto en vivo. Incrementa usage_count y establece last_used para que una edición cuente como un toque.

Compensación — sin pista de auditoría. update sobrescribe el contenido anterior. El texto antiguo no se conserva en ningún lugar. Esto mantiene el esquema limpio; una versión futura puede añadir memory_learn_history más una tabla learnings_history inmutable para usuarios que necesiten recuperación en un punto en el tiempo. Si necesitas una pista de auditoría hoy, memory_learn_archive(reason: "wrong") el aprendizaje antiguo y memory_learn el nuevo como una fila nueva — el texto antiguo permanece en la fila archivada.

Reflexión — qué es importante ahora mismo

memory_reflect({ lookbackDays: 7, staleThresholdDays: 30 })

Paso de agregación sobre el flujo de memoria reciente — el paso de reflexión de Stanford Generative Agents, sin el LLM. Devuelve un payload estructurado MÁS un resumen en Markdown que cubre:

• Aprendizajes más usados — los N principales por usage_count tocados dentro del período de retroceso.
• Aprendizajes obsoletos — creados hace más de staleThresholdDays y nunca recuperados. Candidatos a archivar.
• Entidades activas — las N principales por nuevas observaciones dentro del período de retroceso.
• Decisiones abiertas — más antiguas que el período de retroceso y verified = 0. Candidatas a seguimiento.

El Markdown es para que el LLM lo lea al inicio de la sesión; los campos estructurados son para automatización posterior (Claude Code Hook, flujo n8n) que quiera reaccionar sin volver a analizar. Pasa project para limitar a un proyecto. Sleeptime mediante hooks. Letta / Zep / Mem0 ejecutan la reflexión en un bucle de "sleeptime" en segundo plano. Nosotros ejecutamos bajo demanda porque somos un daemon stdio sin estado — pero obtienes la semántica de sleeptime gratis conectando un hook de SessionStart o SessionEnd de Claude Code (o un cron de n8n, o una entrada de crontab) que llame a memory_reflect. El resumen llega al contexto del LLM al mismo tiempo que tu snapshot de memory_session_start. Cero infraestructura nueva.

Herramientas (25)

Sesiones

memory_session_start -- Llama a esto primero en cada conversación. Carga el contexto de tus últimas 3 sesiones (resúmenes, aprendizajes recientes) para que tu IA sepa en qué estabas trabajando. Parámetro opcional project para delimitar sesiones por proyecto.

memory_session_end -- Llama al final para guardar un resumen. Pasa una cadena summary describiendo lo que se logró. La próxima sesión lo carga automáticamente. Sin argumentos, cierra la sesión activa.

Aprendizajes

memory_learn -- La herramienta central. Almacena una pieza de conocimiento con una categoría y contenido. Categorías: pattern (éxito recurrente), mistake (lo que salió mal), insight (realización estratégica), research (conocimiento externo), architecture, infrastructure, tool, workflow, performance, security. El guardián de duplicados verifica si el contenido idéntico ya está almacenado. Si es así, incrementa el contador de uso en lugar de crear un duplicado. Para extender una entrada existente en lugar de añadir una nueva, usa memory_learn_update con su id. Opcional: tags, confidence (0-1), project, memoryType (episódico o semántico, auto-clasificado si se omite).

memory_recall -- Búsqueda rápida solo en aprendizajes. Pasa una cadena query para búsqueda por palabras clave, u omítela para obtener los aprendizajes más recientes. Buena para preguntas tipo "¿qué aprendí sobre X?". Usa limit para controlar cuántos resultados devolver (por defecto 10).

memory_search -- Búsqueda unificada en todo: aprendizajes, decisiones, entidades y observaciones. Usa FTS5 con ranking bm25. Las consultas de varias palabras coinciden con cualquiera de las palabras y clasifican por relevancia. Usa el array types para filtrar (p. ej. ["learning", "decision"]). Esta es la herramienta de búsqueda más amplia.

memory_learn_archive (v2.1+) -- Eliminación suave de un aprendizaje. La fila permanece en la base de datos (para que las consultas asOf que la referencien sigan resolviéndose) pero nunca reaparece en el recuerdo o la búsqueda. El reason opcional se almacena en lifecycle_state como archived:<reason>. Idempotente — llamar dos veces devuelve already_archived.

memory_learn_update (v2.1+) -- Edita un aprendizaje activo (content / confidence / tags). Se requiere al menos un campo. Incrementa usage_count + last_used para que una edición cuente como un toque. Re-embedde atómicamente cuando content cambia (patrón F4: calcular fuera de la transacción, escribir dentro de un db.transaction() sincronizado). Rechaza ediciones a aprendizajes archivados con code: 'ARCHIVED'.

memory_learn_bulk (v2.2+) -- Inserción por lotes de hasta 500 aprendizajes en una sola llamada atómica. Cada elemento acepta los mismos campos que memory_learn. Guardián de duplicados solo-exactos (sin fusión difusa) para que el resultado sea insertar-o-saltar determinista; los contenidos duplicados dentro del lote se colapsan en la primera aparición. Solo los contenidos nuevos se embedden, en una sola pasada de modelo por lotes. Para restaurar una copia de seguridad, sembrar una base de datos nueva o migrar desde otro sistema.

Cuándo usar recall vs search: Usa recall cuando quieras aprendizajes específicamente. Usa search cuando quieras encontrar cualquier cosa en todos los tipos, incluyendo entidades y decisiones.

Decisiones

memory_decide -- Registra una decisión con contexto estructurado. Parámetros: title (lo que se decidió), decision (la elección tomada), reasoning (por qué), alternatives (qué más se consideró). Opcional: confidence, project, tags. Esto es útil para mirar hacia atrás decisiones pasadas meses después y entender por qué elegiste algo.

Grafo de conocimiento

memory_entity_observe -- Registra un hecho sobre una persona, proyecto, empresa, herramienta o cualquier otra entidad. Si la entidad no existe aún, se crea automáticamente. Parámetros: entityName, entityType (persona, proyecto, empresa, herramienta, concepto, etc.), content (el hecho). Las observaciones son bi-temporales, lo que significa que pueden ser superadas con el tiempo sin perder historia.

memory_entity_search -- Búsqueda difusa en nombres de entidades y sus observaciones. Encuentra "Claude" incluso si buscas "claude ai". Filtro opcional entityType para acotar resultados.

memory_entity_open -- Carga una vista completa de entidad: la entidad misma, todas sus observaciones actuales y todas sus relaciones con otras entidades. Busca por name o id. v2.1: parámetro opcional asOf para una vista bi-temporal en un punto del tiempo — "¿qué sabía sobre esta entidad en la fecha X?"

memory_entity_relate -- Crea un borde dirigido y tipado entre dos entidades. Parámetros: fromEntityId, toEntityId, relationType (p. ej. "works_at", "uses", "created", "depends_on"). Opcional weight (0-1). Construye un grafo de cómo se conectan las cosas.

memory_contradictions (v2.1+) -- Escáner sin LLM que detecta pares de observaciones con alta similitud coseno pero que discrepan en marcadores de negación o confianza. El cliente de IA (Claude / Cursor) juzga los candidatos. Alcance opcional: entityId o entityName + entityType. Controles: minCosine (por defecto 0.75), minConfidenceDrift (por defecto 0.2), limit (por defecto 20). Requiere sqlite-vec — devuelve VECTOR_DISABLED si no está cargado.

memory_observation_supersede (v2.2+) -- El brazo de ejecución para memory_contradictions: retira una observación obsoleta estableciendo valid_to (una lápida). La fila permanece en la base de datos para que una consulta asOf aún la muestre, pero desaparece de memory_search y memory_entity_open en vivo. Pasa supersededById para establecer el corte al valid_from del hecho más nuevo (supersesión de hechos de Zep), validTo para un instante explícito, o ninguno para now(). Guardas de misma-entidad + auto-supersesión; idempotente.

Tipos de entidad recomendados: person, project, company, tool, concept, service, team. Usa lo que tenga sentido para tu dominio.

Reflexión

memory_reflect (v2.1+) -- Pasada de agregación sobre el flujo de memoria reciente. Devuelve datos estructurados más un resumen en Markdown que cubre: aprendizajes más usados (top N por usage_count tocados en la ventana de retroceso), aprendizajes obsoletos (creados hace > staleThresholdDays, nunca recordados), entidades calientes (top N por nuevas observaciones en la ventana), decisiones abiertas (verified = 0, más antiguas que la ventana). Sin LLM — el paso de reflexión de Stanford Generative Agents sin la llamada a la API. Valores por defecto: lookbackDays: 7, staleThresholdDays: 30, limit: 5. Filtro opcional project.

memory_insights -- Estadísticas generales: cuántos días de memoria, sesiones totales, aprendizajes, decisiones, entidades. Desglose por categoría y por tipo de entidad. Bueno para momentos de "¿qué sabe Claude sobre mí?". Filtro opcional project.

memory_profile -- Almacena información personal localmente. Usa set para guardar campos (nombre, rol, preferencias, idioma, zona horaria), usa get para recuperarlos. Tu IA puede leer esto al inicio de la sesión para personalizar su comportamiento.

memory_guide -- Ayuda integrada. Temas: quickstart (cómo empezar), session (flujo de trabajo de sesiones), search (cómo funciona la búsqueda), entities (grafo de conocimiento explicado), learn (categorías de aprendizaje), privacy (dónde viven los datos, qué se recopila).

Portabilidad (v2.2+)

memory_export -- Vuelca toda la memoria — aprendizajes, decisiones, entidades, observaciones, relaciones, sesiones, perfil, meta — a un sobre JSON versionado en camelCase (format: "studiomeyer-memory-export", version: 1). Los embeddings no se exportan; se re-derivan en la importación, así el archivo permanece pequeño y agnóstico al modelo. Banderas: includeSessions (por defecto true), includeArchived (por defecto true). Tú eres dueño de tus datos — ya es un único archivo SQLite, y ahora también es un documento portable.

memory_import -- Ingiere un sobre memory_export ({ data: <envelope> }). Puramente aditivo e idempotente: cada escritura es INSERT OR IGNORE en el id de origen, así que re-importar el mismo archivo es un no-op y nunca sobrescribe una fila existente. Orden seguro para FK con saltos de referencias colgantes (un salto contado, nunca un lanzamiento). Re-embedde sobre la marcha. No hay modo replace por diseño — para borrar un almacén local, elimina memory.sqlite. El mismo sobre también se importa en el nivel alojado StudioMeyer Memory, así que esta es tu rampa de entrada cuando superes una sola máquina.

Consejos

• Empieza con sesiones y aprendizajes. Solo llamar a memory_session_start al principio y memory_learn cuando algo importante surja ya te da el 80% del valor.
• Usa entidades para personas y proyectos. Cuando menciones a un colega, cliente o proyecto repetidamente, crea una entidad. Con el tiempo construyes un grafo de conocimiento que tu IA puede recorrer.
• Las decisiones están subestimadas. Dentro de tres meses no recordarás por qué elegiste Postgres sobre SQLite para ese proyecto. memory_decide captura el razonamiento.
• Deja que tu IA conduzca. Una vez que las herramientas están disponibles, tu IA empezará a usarlas naturalmente. No necesitas llamar herramientas manualmente. Di "recuerda esto" y llama a memory_learn. Di "¿qué sabes sobre Sarah?" y llama a memory_entity_search.
• Haz copia de seguridad de tu archivo SQLite. Es un solo archivo. Cópialo a una unidad USB, Dropbox, donde sea. También puedes abrirlo con cualquier navegador SQLite para inspeccionar lo que tu IA ha aprendido.

Características

• Grafo de conocimiento -- no solo texto plano. Entidades, observaciones bi-temporales, relaciones tipadas.
• Guardián de duplicados -- la verificación de similitud FTS5 evita almacenar lo mismo dos veces. Contador de uso en su lugar.
• Contexto de sesión -- carga automáticamente las últimas 3 sesiones al inicio. Tu IA retoma donde lo dejaste.
• Seguimiento de decisiones -- registra decisiones con razonamiento y alternativas. Único entre los servidores de memoria.
• Búsqueda de texto completo -- FTS5 con ranking bm25 en aprendizajes, decisiones, entidades, observaciones.
• Un solo archivo SQLite -- un archivo, portable, respaldable, eliminable. Modo WAL para acceso concurrente.
• Cero configuración -- npx y listo. Sin Docker, sin Postgres, sin Redis, sin claves de API.

Dónde viven tus datos

Todo en un archivo SQLite. Respáldalo, muévelo, elimínalo — es tuyo.

SO	Ruta
macOS	~/Library/Application Support/local-memory-mcp/memory.sqlite
Linux	~/.local/share/local-memory-mcp/memory.sqlite
Windows	%APPDATA%\local-memory-mcp\memory.sqlite

Anulación: MEMORY_DB_PATH=/your/preferred/path.sqlite

Privacidad

• Tus datos nunca salen de tu máquina
• Sin telemetría, sin llamadas a casa, sin analíticas
• Sin cuenta requerida, sin claves de API necesarias
• Código abierto -- lee cada línea de código

Comparación

Característica	local-memory-mcp	Penfield	Official MCP Memory	MemPalace	Mem0	Zep	Letta	AutoMem
Local-first	Sí	Sí	Sí	Sí	No (nube)	No (nube)	Parcial	Sí
Recuperación híbrida (BM25 + vector)	Sí (RRF)	Sí	No	No (solo vector)	Solo vector	Solo vector	Vector + grafo	Vector + grafo
Incrustaciones multilingües	Sí (e5-small, DE/EN/ES + 100 más)	Desconocido	No	Desconocido	Inclinado al inglés	Inclinado al inglés	Mixto	Mixto
Grafo de conocimiento	Sí (entidades + relaciones)	Sí	Sí (tripletas)	No	Nivel de pago	Sí	Sí	Sí (FalkorDB)
Hechos bi-temporales	Sí (esquema)	Desconocido	No	No	Sí	Sí	Parcial	Desconocido
Guardia de duplicados	Sí (FTS5 + similitud)	No	No	No	Desconocido	Desconocido	Desconocido	Desconocido
Seguimiento de decisiones	Sí (único)	No	No	No	No	No	No	No
Contexto de sesión	Sí (carga automática)	Sí	No	No	No	No	Sí	Sí
Herramientas	25	17	5	29	API	API	API	API
Bi-temporal asOf	Sí (v2.1)	Desconocido	No	No	Sí	Sí	Parcial	Desconocido
Escáner de contradicciones	Sí (v2.1, sin LLM)	No	No	No	Impulsado por LLM	Impulsado por LLM	No	No
Supersesión de hechos	Sí (v2.2, preservando asOf)	No	No	No	Impulsado por LLM	Sí	Parcial	Desconocido
Reflexión / consolidación	Sí (v2.1, sin LLM)	No	No	No	Impulsado por LLM	Sí (tiempo de sueño)	Sí (tiempo de sueño)	No
Exportación / importación portátil	Sí (v2.2, sobre JSON)	Desconocido	No	No	API	API	.af archivo	Desconocido
Lenguaje	TypeScript	TypeScript	TypeScript	Python	Python	Python	Python	Python
Almacenamiento	SQLite + sqlite-vec	SQLite	Archivo JSON	ChromaDB	Nube	Nube	Varios	FalkorDB + Qdrant
Claves API necesarias	No	No	No	No	Sí (nube)	Sí (nube)	Opcional	Opcional
Instalación	npx o .mcpb	npx	npx	pip + venv	Regístrate	Regístrate	pip / Docker	pip / Docker
Paquete multiplataforma	Sí (4 SO)	No	No	n/a	n/a	n/a	n/a	n/a
Precio	Gratis para siempre	Gratis	Gratis	Gratis	$0-249/mes	$0-499/mes	Gratis	Gratis

Dónde destacamos: el único MCP de memoria local, con licencia MIT y sin necesidad de claves API que ofrece recuperación híbrida (BM25 + coseno vectorial vía RRF) con incrustaciones multilingües e instaladores de un clic para todos los sistemas operativos de escritorio. El seguimiento de decisiones sigue siendo exclusivo nuestro.

local-memory-mcp vs. StudioMeyer Memory

Dos productos, mismo equipo, diferentes casos de uso:

	local-memory-mcp (este repositorio)	StudioMeyer Memory (alojado)
Dónde	Tu máquina (SQLite + sqlite-vec)	Nube (nuestro propio Postgres, Hetzner Alemania, UE)
Herramientas	25	56
Búsqueda	Híbrido FTS5 + sqlite-vec (RRF)	FTS5 + pgvector + reordenamiento con cross-encoder
Incrustaciones	Local (multilingual-e5-small, 384-dim)	Nube (múltiples modelos, reordenamiento)
Multi-dispositivo	No	Sí
Multi-agente	No	Sí
Precio	Gratis para siempre	Nivel gratuito / EUR 9 Pro / EUR 19 Team
Instalación	npx o .mcpb (Linux / macOS / Windows)	memory.studiomeyer.io
Repositorio	local-memory-mcp	studiomeyer-memory (documentación)

Comienza local. Mejora cuando necesites equipos, sincronización multi-dispositivo o reordenamiento con cross-encoder — memory_export produce un sobre que se importa directamente al nivel alojado, así que llevas toda tu memoria contigo.

También de StudioMeyer

Servidor	Qué hace	Enlace
StudioMeyer Memory	Memoria de IA alojada con 56 herramientas, búsqueda semántica, multi-agente	memory.studiomeyer.io
StudioMeyer CRM	CRM nativo de IA -- 33 herramientas, pipeline, clientes potenciales, ingresos	crm.studiomeyer.io
StudioMeyer GEO	Monitoreo de visibilidad de IA -- 23 herramientas, 8 plataformas LLM	geo.studiomeyer.io
MCP Crew	Personajes de agente para Claude -- 10 herramientas, 8 roles, 3 flujos de trabajo	crew.studiomeyer.io

Seguridad

Consulta SECURITY.md para el modelo de amenazas, el proceso de reporte y notas sobre falsos positivos conocidos de escáneres SAST. En particular: db.exec(schema) en src/db/client.ts es el ejecutor de cadenas SQL de better-sqlite3, no child_process.exec — algunos escáneres basados en patrones lo marcan sin resolución de importaciones. El repositorio contiene cero código de ejecución de shell (verifica con grep -rn child_process src/).

Contribuciones

Las incidencias y solicitudes de extracción son bienvenidas. Consulta CONTRIBUTING.md.

Acerca de StudioMeyer

StudioMeyer es un estudio de IA y diseño con sede en Palma de Mallorca, que trabaja con clientes en todo el mundo. Construimos sitios web personalizados e infraestructura de IA para pequeñas y medianas empresas. Pila de producción en Claude Agent SDK, MCP y n8n, con Sentry, Langfuse y LangGraph para observabilidad y una capa de protección interna.

Licencia

MIT

---

Construido por StudioMeyer -- estudio web con enfoque en IA desde Mallorca.