RemembrallMCP

👁 Licencia: MIT
👁 Crates.io
👁 CI
👁 Docker

Memoria de conocimiento persistente e inteligencia de código para agentes de IA. Núcleo en Rust, Postgres + pgvector, protocolo MCP.

El problema: Los agentes de codificación de IA no tienen estado. Cada sesión comienza desde cero: sin memoria de decisiones pasadas, sin comprensión de cómo encaja el código base, sin forma de saber qué se rompe cuando cambias algo.

La solución: RemembrallMCP ofrece a los agentes dos cosas que la mayoría de las herramientas de memoria no tienen:

1. Memoria persistente - Decisiones, patrones y conocimiento organizacional que sobreviven entre sesiones. La búsqueda híbrida semántica + de texto completo encuentra contexto relevante al instante.

2. Grafo de dependencias de código - Un mapa en vivo de tu código base construido con tree-sitter. Funciones, clases, importaciones y relaciones de llamada en 8 lenguajes. Pregunta "¿qué se rompe si cambio esto?" y obtén una respuesta en milisegundos, antes de que el agente toque nada.

remembrall_recall("authentication middleware patterns")
-> 3 relevant memories from past sessions

remembrall_index("/path/to/project", "myapp")
-> Builds dependency graph: 847 symbols, 1,203 relationships

remembrall_impact("AuthMiddleware", direction="upstream")
-> 12 files depend on AuthMiddleware (with confidence scores)

remembrall_store("Switched from JWT to session tokens because...")
-> Decision stored for future sessions

Por qué es importante el grafo de código

Sin RemembrallMCP, los agentes exploran tu código base desde cero en cada sesión. Claude Code genera agentes Explore, Codex lee docenas de archivos, Cursor busca con grep a través de directorios; todo consumiendo tokens y tiempo solo para entender qué llama a qué. Una sola tarea de "encontrar todos los llamadores de esta función" puede costar miles de tokens a través de múltiples llamadas a herramientas.

Con RemembrallMCP, esa misma consulta es una única llamada remembrall_impact que devuelve en <1ms con cero tokens de exploración. El grafo de dependencias ya está construido y esperando.

Los ahorros escalan con el tamaño del código base. En un proyecto pequeño, un agente puede usar grep y leer su camino. En un monorepo de 500 archivos, esa exploración se convierte en el cuello de botella: los agentes alcanzan límites de contexto, generan múltiples sub-agentes o pasan por alto dependencias entre módulos por completo. Las consultas de grafo de RemembrallMCP se mantienen por debajo de 10ms independientemente del tamaño del proyecto porque la estructura está pre-indexada en Postgres, no descubierta en tiempo de ejecución.

Esta es la diferencia entre un agente que explora tu código base cada vez y uno que ya lo entiende.

Benchmarks

RemembrallMCP está actualmente evaluado en dos superficies:

• Productividad del agente en tareas de código - Probado en pallets/click v8.1.7 (594 símbolos, 1,589 relaciones). Cinco tareas de codificación idénticas ejecutadas con y sin RemembrallMCP. Informe completo.

• Calidad de recuperación de memoria - Arnés de recuperación local ejecutado contra 31 consultas de verdad fundamental que cubren calidad de búsqueda, filtrado, casos extremos, clasificación y latencia.

Los ahorros se acumulan en códigos base más grandes. Click tiene ~90 archivos; en un monorepo de más de 500 archivos, los agentes sin RemembrallMCP necesitan proporcionalmente más llamadas de exploración, mientras que las consultas de grafo se mantienen por debajo de 10ms independientemente del tamaño.

Ejecuta los benchmarks tú mismo: mira benchmarks/ para el arnés y las definiciones de tareas.

Para la estrategia de benchmark más amplia a través de recuperación de memoria, memoria a largo plazo, corrección del grafo de código y productividad del agente, mira docs/benchmark-roadmap.md.

Requisitos

• Docker (para la configuración más fácil) o PostgreSQL 16 con pgvector

• Para la ingesta de GitHub: GitHub CLI (gh) instalado y autenticado

Related MCP server: smriti

Inicio rápido

Opción 1: Docker Compose (más fácil)

git clone https://github.com/cdnsteve/remembrallmcp.git
cd remembrallmcp

# Start Postgres + initialize schema + download embedding model
docker compose up -d

# Verify it's running
docker compose exec remembrall remembrall status

Eso es todo. Postgres con pgvector, el esquema y el modelo de incrustación se configuran automáticamente. La base de datos y la caché del modelo persisten entre reinicios.

Para ejecutar el servidor MCP:

docker compose run --rm remembrall

Opción 2: Descargar binario precompilado

# macOS (Apple Silicon)
curl -fsSL https://github.com/cdnsteve/remembrallmcp/releases/latest/download/remembrall-aarch64-apple-darwin.tar.gz | tar xz
sudo mv remembrall /usr/local/bin/

# Linux (x86_64)
curl -fsSL https://github.com/cdnsteve/remembrallmcp/releases/latest/download/remembrall-x86_64-unknown-linux-gnu.tar.gz | tar xz
sudo mv remembrall /usr/local/bin/

# Initialize (sets up Postgres via Docker, creates schema, downloads model)
remembrall init

Opción 3: Construir desde la fuente (requiere Rust 1.94+)

cargo build -p remembrall-server --release
# Binary is at target/release/remembrall

remembrall init

Conectar a tu cliente MCP

Codex

Codex utiliza el mismo formato de definición de servidor MCP. Registra el servidor como remembrall y apúntalo al binario instalado o a tu compilación de lanzamiento local.

Si remembrall está instalado en PATH:

{
 "mcpServers": {
 "remembrall": {
 "command": "remembrall"
 }
 }
}

Si se ejecuta desde un checkout de fuente local:

{
 "mcpServers": {
 "remembrall": {
 "command": "/path/to/remembrallmcp/target/release/remembrall",
 "env": {
 "DATABASE_URL": "postgres://postgres:postgres@localhost:5450/remembrall"
 }
 }
 }
}

Si usas Docker Compose desde Codex:

{
 "mcpServers": {
 "remembrall": {
 "command": "docker",
 "args": ["compose", "-f", "/path/to/remembrallmcp/docker-compose.yml", "run", "--rm", "-T", "remembrall"]
 }
 }
}

Reinicia Codex después de añadir el servidor para que se reconecte y cargue las herramientas.

Claude Code, Cursor y otros clientes MCP

Añádelo al .mcp.json de tu proyecto (funciona con Claude Code, Cursor y cualquier cliente compatible con MCP).

Si usas un binario precompilado o construido desde la fuente:

{
 "mcpServers": {
 "remembrall": {
 "command": "remembrall"
 }
 }
}

Si usas Docker Compose:

{
 "mcpServers": {
 "remembrall": {
 "command": "docker",
 "args": ["compose", "-f", "/path/to/remembrallmcp/docker-compose.yml", "run", "--rm", "-T", "remembrall"]
 }
 }
}

Si se ejecuta desde la fuente (no instalado en PATH):

{
 "mcpServers": {
 "remembrall": {
 "command": "/path/to/remembrallmcp/target/release/remembrall",
 "env": {
 "DATABASE_URL": "postgres://postgres:postgres@localhost:5450/remembrall"
 }
 }
 }
}

Reinicia tu cliente MCP. Las 9 herramientas estarán disponibles automáticamente.

Pruébalo

> "Store a memory: We chose Postgres over MongoDB because our query patterns
 are relational. Type: decision, tags: database, architecture"

> "Recall what we know about database decisions"

> "Index this project and show me the impact of changing UserService"

Herramientas MCP

Memoria

Inteligencia de código

Lenguajes soportados

Puntuaciones medidas contra proyectos reales de código abierto (Click, Gson, Axios, bat, Cobra, Sidekiq, Hono, Exposed) utilizando pruebas automatizadas de verdad fundamental.

Inicio en frío

Una nueva instancia de RemembrallMCP no tiene conocimiento. Usa las herramientas de ingesta para arrancar desde el historial del proyecto existente.

Desde el historial de PR de GitHub:

> remembrall_ingest_github repo="myorg/myrepo" limit=100

Obtiene PRs fusionados a través de gh, digiere títulos y cuerpos en recuerdos y los etiqueta por proyecto. Los PRs con menos de 50 caracteres de cuerpo se omiten. La deduplicación por huella digital de contenido evita la re-ingesta en ejecuciones repetidas.

Desde documentos markdown:

> remembrall_ingest_docs path="/path/to/project"

Recorre el árbol de directorios, encuentra todos los archivos .md, los divide por encabezados de sección H2 y almacena cada sección como un recuerdo buscable. Omite node_modules, .git, target y directorios similares. Bueno para README, ARCHITECTURE, ADRs y cualquier documento escrito.

Ejecuta ambos una vez por proyecto. Después de la ingesta, remembrall_recall tiene contexto inmediato.

Arquitectura

Source Code Organizational Knowledge
 | |
 v v
Tree-sitter Parsers Ingestion Pipeline
(8 languages) (GitHub PRs, Markdown docs)
 | |
 v v
+--------------------------------------------------+
| Postgres + pgvector |
| |
| memories (text + embeddings + metadata) |
| symbols (functions, classes, methods) |
| relationships (calls, imports, inherits) |
+--------------------------------------------------+
 |
 MCP Server (stdio)
 |
 Any MCP-compatible AI agent

• Análisis: tree-sitter (enlaces de Rust, sin Python en la tubería)

• Incrustaciones: fastembed (all-MiniLM-L6-v2, 384-dim, ONNX Runtime en proceso)

• Búsqueda: RRF híbrido (similitud de coseno semántica + tsvector de texto completo)

• Consultas de grafo: CTEs recursivos con detección de ciclos y decaimiento de confianza

• Transporte: stdio vía rmcp

Comandos CLI

Configuración

Archivo de configuración: ~/.remembrall/config.toml (creado por remembrall init)

Las variables de entorno anulan los valores del archivo de configuración:

Estructura del proyecto

crates/
 remembrall-core/ # Library - parsers, memory store, graph store, embedder
 remembrall-server/ # MCP server + CLI binary
 remembrall-test-harness/ # Parser quality testing against ground truth
 remembrall-recall-test/ # Search quality testing
docs/ # Architecture and test plan docs
test-fixtures/ # Ground truth TOML files for 8 languages
tests/ # Recall test fixtures

Rendimiento

Licencia

MIT

Maintenance

Resources

• NPM Package
• GitHub Repository
Need Help?Related Servers