Una capa de memoria unificada y compartible para todas las aplicaciones de IA que utilizas

Tus herramientas saben mucho sobre ti, pero no se comunican entre sí. Cursor recuerda cosas diferentes a las que recuerda Claude Desktop; Windsurf sabe qué repositorio abriste ayer; un bloc de notas de Gemini CLI contiene fragmentos que nunca volverás a ver. Core soluciona eso. Es un servidor de memoria compartible y de prioridad local que se encuentra junto a tus editores y herramientas de agente, proporcionándoles un cerebro común: una búsqueda, un historial, un lugar para almacenar y recuperar lo que importa. Está diseñado para conectarse a clientes de agente modernos (Cursor, Claude Desktop y Claude Code, Gemini CLI, Windsurf, Kiro de AWS, VS Code, Cline) para que el contexto se mueva contigo en lugar de quedarse estancado en cada aplicación.

Este artículo explica qué es Core, por qué es esencial una capa de memoria, cómo funciona y cómo ejecutarlo, ya sea de forma local para ti mismo o en un equipo pequeño. Al final, tendrás Core en funcionamiento, conectado a tus herramientas favoritas y ya recordando cosas útiles en tu nombre.

Qué es Core (y por qué lo quieres)

Core es un servidor ligero + CLI que ofrece tres cosas:

1. Un modelo de memoria unificado: añade notas, datos, decisiones, fragmentos, metadatos de credenciales, registros de ejecución y resúmenes de «lo que hemos aprendido». Todo se marca con la fecha y la hora, se etiqueta y se atribuye a su herramienta o agente de origen.
2. Recuperación inteligente: recupera información mediante consultas en lenguaje natural o filtros estructurados. Core combina la similitud semántica, la actualidad y las relaciones gráficas para mostrar la memoria adecuada en el momento adecuado.
3. Interfaces abiertas: habla MCP (Model Context Protocol) para la integración de agentes/IDE y también expone una API HTTP + CLI limpia. Así es como se conecta a Cursor, Claude Desktop/Code, Gemini CLI, Windsurf, AWS Kiro, VS Code y Cline sin adaptadores a medida.

Por qué es importante: los agentes actuales son potentes, pero olvidadizos. La fragmentación del contexto cuesta tiempo, genera trabajo duplicado y hace que los asistentes sean inconsistentes. Una memoria compartida convierte cada herramienta en un participante en una conversación continua.

El modelo de memoria (creado para humanos y agentes)

Core trata la memoria como datos de primera clase con opiniones que realmente ayudan:

• Espacios de trabajo y ámbitos: mantén separadas la memoria personal, la del equipo y la del proyecto. Los agentes solo consultan lo que se les permite ver.
• Tipos: note, fact, decision, preference, snippet, doc_chunk, run_log, tool_context. Los diferentes tipos obtienen diferentes TTL predeterminados y comportamientos de clasificación.
• Procedencia: source_app, source_user, source_url, y hash  para deduplicación/auditoría.
• Etiquetas y temas: etiquetas de formato libre; los temas se expanden automáticamente a través de incrustaciones para agrupar memorias relacionadas.
• Controles de vida útil:  ttl, pin (nunca caduca), expires_at, y forget() para cumplir con el «derecho al olvido» en segundos.
• Bordes del gráfico: vincula recuerdos (supports, contradicts, derived_from, similar_to) para que Core pueda ampliar una consulta de recuperación al contexto circundante adecuado.
• Archivos adjuntos: blobs de referencia (imágenes, archivos) manteniendo resúmenes que dan prioridad al texto y son fáciles de usar para los agentes.

Bajo el capó, Core utiliza un índice vectorial, un almacén temporal y un gráfico de conocimiento ligero. Un clasificador multisignal los combina para que no tengas que pensar en la «lógica de búsqueda»: solo tienes que preguntar.

Cómo se integra Core en tus herramientas

Core está diseñado en torno a MCP para agentes y clientes IDE:

• Editores/agentes: Cursor, Claude Desktop y Claude Code, VS Code (a través del puente MCP), Windsurf, Cline, Gemini CLI y AWS Kiro pueden conectarse a Core como un servidor MCP.
• Flujos de trabajo: «Guarda esto como un dato», «Recuerda lo que decidimos sobre la autenticación», «¿Cuál era la URL de staging?», «Resume las últimas tres ejecuciones» o «Rehidrata todo el contexto sobre el servicio de facturación».

Como la interfaz es estándar, cambiar de herramienta no te cuesta memoria. Tu asistente en una aplicación puede beneficiarse de lo que le enseñaste ayer a otra.

Cosas típicas que Core recuerda (y recupera al instante)

• Preferencias: «Usar pnpm», «tabulaciones en lugar de espacios», «preferir FastAPI para servicios rápidos».
• Estado del proyecto: «URL de la base de datos de staging», «cómo ejecutar migraciones», «comandos que utilizamos para corregir la compilación n.º 482».
• Fragmentos de documentación: párrafos clave de README, ADR, esquemas de API, almacenados como doc_chunk con la fuente original.
• Decisiones: «Elegimos Postgres en lugar de Dynamo debido a las uniones analíticas».
• Fragmentos: «Middleware JWT que nos gusta», «Plantilla Helm para ingress», «Inicialización común de LangChain».
• Notas de ejecución: «Benchmark en M3 Max: 312 req/s con worker=8».

Metadatos de credenciales: no el secreto en sí, sino dónde se encuentra y cómo rotarlo.

Instalación y ejecución de Core

Los comandos siguientes asumen un shell similar a Unix. Los nombres son representativos; ajústelos a su gestor de paquetes o ruta binaria.

Opción A: una sola línea con la CLI (desarrollo local)

# Install the Core CLI (local user)
npm i -g @heysol/core
# Initialize config and local storage
core init
# Start the server (opens on localhost:7077 by default)
core serve

Lo que obtienes: un servidor Core local con un espacio de trabajo predeterminado (personal), un directorio de almacenamiento (~/.core) y una clave API impresa una vez.

Opción B: Docker (fácil, reproducible)

docker run -d –name core \
-p 7077:7077 \
-e CORE_API_KEY=dev-key \
-e CORE_STORAGE_DIR=/data \
-v $HOME/.core:/data \
ghcr.io/redplanethq/core:latest

Opción C: implementación en equipos pequeños (Docker Compose + Postgres)

services:
core:
image: ghcr.io/redplanethq/core:latest
ports: [«7077:7077»]
environment:
CORE_API_KEY: ${CORE_API_KEY}
CORE_DB_URL: postgres://core:core@db:5432/core
CORE_EMBEDDINGS: «openai» # or «local»
OPENAI_API_KEY: ${OPENAI_API_KEY}
volumes:
– ./core-data:/data
db:
image: postgres:16
environment:
POSTGRES_DB: core
POSTGRES_USER: core
POSTGRES_PASSWORD: core
volumes:
– ./pg-data:/var/lib/postgresql/data

Ejecútalo con docker compose up -d.

Por defecto, se utiliza primero el almacenamiento local. También puedes utilizar un almacén SQLite integrado si no deseas utilizar Postgres.

Conectar Core a tus aplicaciones

Conéctate como un servidor MCP (Cursor, Claude Desktop/Code, Windsurf, VS Code, Cline, Gemini CLI, AWS Kiro)

La mayoría de los clientes compatibles con MCP te permiten añadir un servidor MCP personalizado. Elige el modo de comando y dirígete a Core:

• Comando:  core mcp --stdio
• (Alternativamente:  core mcp --port 3920  si su cliente prefiere TCP).
• Entorno: establezca CORE_URL=http://localhost:7077 y CORE_API_KEY=…… para que el proceso MCP pueda comunicarse con el servidor Core.

Después de añadirlo, su agente debería mostrar herramientas como:

• memory.upsert, memory.recall, memory.forget, memory.queryGraph, memory.pin, memory.import
• workspace.list, workspace.switch, topic.suggest

A partir de ahí, puedes decir cosas como:

«Guardar: Nuestro bucket S3 de producción es s3://acme-prod-artifacts».

«Recordar la última decisión sobre nuestro proveedor de autenticación».

«Buscar fragmentos relacionados con «retry + axios»».

Usar la API HTTP y la CLI directamente

Guardar una memoria

curl -X POST "http://localhost:7077/v1/memories" \
  -H "Authorization: Bearer $CORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "workspace": "personal",
    "type": "fact",
    "text": "We use pnpm and Node 20 in the monorepo.",
    "tags": ["tooling","node"],
    "source": {"app":"cursor","user":"me"},
    "ttl": "365d"
  }'

Recordatorio por pregunta

curl -X POST "http://localhost:7077/v1/recall" \
  -H "Authorization: Bearer $CORE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "workspace": "personal",
    "query": "How do I run DB migrations locally?",
    "limit": 8
  }'

Pin / Olvidar

core memory pin "billing-runbook"
core memory forget --id mem_01HXYZ123

Importar documentos por partes (compatible con RAG)

core import docs ./docs --workspace project-billing --tag docs

Core extrae texto, lo divide en fragmentos semánticamente coherentes, lo incrusta y almacena la procedencia (ruta + hash git).

Clasificación y recuperación sin necesidad de supervisión

El motor de recuperación de Core combina múltiples señales:

• Similitud semántica: las incrustaciones convierten tu consulta en geometría.
• Ponderación temporal: los recuerdos más recientes se clasifican en posiciones más altas, a menos que se fijen.
• Expansión gráfica: si un recuerdo está profundamente conectado con el tema de la consulta, sus vecinos también se incluyen.
• Potenciadores sensibles al tipo: una decisión suele tener mayor rango que una nota aleatoria; un fragmento puede tener mayor rango que un párrafo genérico.

Puedes anular el comportamiento con sugerencias de consulta como type:  type:snippet, tag:infra, since:30d, or expand:2.

Funciones de privacidad, seguridad y cumplimiento normativo.

• Almacenamiento local con cifrado opcional en reposo.
• El «derecho al olvido» es instantáneo: forget() elimina el registro, sus incrustaciones y los bordes del gráfico.
• Procedencia y auditoría: cada escritura incluye quién, qué y cuándo.
• Ámbitos y RBAC: lectores frente a escritores; ámbitos solo para agentes para el contexto de las herramientas; espacios de trabajo personales frente a espacios de trabajo en equipo.
• Protección de la información de identificación personal: heurística y listas de permitidos/denegados para evitar guardar secretos o tokens confidenciales como texto sin formato.
• Exportación: exportación JSONL con un solo comando por espacio de trabajo para copias de seguridad o migración.

Patrones de equipo que realmente funcionan.

• Espacios de trabajo por proyecto con lectura/escritura compartida; espacio de trabajo personal para preferencias.
• Guard los resultados de las reuniones como decisiones más un hecho vinculado que codifique el «cómo».
• En las revisiones, utilice Core para recordar las concesiones pasadas en lugar de volver a discutirlas.
• AdjuntA enlaces, no secretos: «Clave API almacenada en la bóveda 1Password «Team Dev», elemento «Acme Staging OpenAI».

Solución de problemas y consejos operativos

• Si un editor no encuentra Core, ejecute core mcp –stdio manualmente y observe los registros.
• ¿Recuperación con alta latencia? Cambie las incrustaciones a un modelo local para desarrollo; utilice un proveedor alojado para producción.
• ¿Muchos archivos pequeños? Utilice el importador CLI para que los fragmentos de documentos se mantengan coherentes y sin duplicados.
• Haz una copia de seguridad de ~/.core (o su base de datos) todas las noches. Considere el almacenamiento de objetos para los archivos adjuntos.

Conclusión

Los agentes son finalmente poderosos, lo que les faltaba era una memoria que te siguiera. Core proporciona a tus herramientas un lugar común que respeta la privacidad para recordar preferencias, decisiones, fragmentos y documentos, y recuperarlos al instante, independientemente de la aplicación en la que te encuentres. El objetivo es sencillo y ambicioso: un cerebro para todos tus asistentes de IA, con prioridad local, que se pueda compartir cuando quieras y fácil de conectar.

Ponlo en marcha, conecta un cliente, guarda tres datos útiles y pide a tu próximo asistente que los recupere. Notarás la diferencia la próxima vez que abras tu editor.