Servidor MCP de CogMemory

Un servidor unificado del Model Context Protocol que proporciona cuatro subsistemas de contexto para agentes de codificación de IA:

1. Memoria — decisiones, convenciones, errores, contexto activo, changelog, plan, tareas, sesiones

2. Grafo de conocimiento — entidades, relaciones, observaciones

3. Especificaciones — documentos extensos (PRD/SRS), opcionalmente vinculados a una entidad del grafo de conocimiento

4. Grafo de código — grafo estructural estático (símbolos/aristas) + trazas de ejecución con nombre + anotaciones generadas por IA

Almacenamiento: SQLite mediante better-sqlite3. Un archivo .db por ámbito.

Inicio rápido

Instalación

git clone <repo> && cd cogmemory-mcp
pnpm install
pnpm run build

Configuración en VS Code

Añade a .vscode/mcp.json (con ámbito de espacio de trabajo):

{
  "servers": {
    "cogmemory": {
      "command": "node",
      "args": ["/absolute/path/to/cogmemory-mcp/dist/index.js"]
    }
  }
}

O añádelo a tu mcp.json de usuario para disponibilidad global.

Ejecutar con MCP Inspector (dev)

pnpm run inspect

Related MCP server: LumenCore

Configuración del ámbito

CogMemory resuelve el ámbito en orden de prioridad:

1. .cogmemory/config.json en la raíz del espacio de trabajo:

   { "scope": "global" }

2. Variable de entorno: COGMEMORY_SCOPE=global

3. Predeterminado: workspace

Rutas

Resolución del espacio de trabajo y soporte multi-raíz

CogMemory resuelve la raíz del espacio de trabajo (donde reside .cogmemory/memory.db) en este orden de prioridad:

1. Argumento de CLI --workspace <path> (prioridad más alta)

2. Variable de entorno COGMEMORY_WORKSPACE

3. Sube desde el CWD buscando el padre más cercano que contenga un directorio .cogmemory/

4. Respaldo al CWD

Espacios de trabajo multi-raíz de VS Code

En un espacio de trabajo multi-raíz de VS Code, cada carpeta es una raíz de espacio de trabajo independiente. CogMemory gestiona esto:

• Raíz única — Funciona automáticamente. VS Code establece el CWD en la carpeta del espacio de trabajo y --workspace se pasa mediante mcp.json.

• Multi-raíz — Cada carpeta del espacio de trabajo puede tener su propio .cogmemory/. Apunta cada una a CogMemory con diferentes rutas --workspace, o coloca un .cogmemory/ compartido en un directorio padre.

mcp.json multi-raíz recomendado (por carpeta):

{
  "servers": {
    "cogmemory-frontend": {
      "command": "node",
      "args": [
        "/path/to/cogmemory-mcp/dist/index.js",
        "--workspace",
        "/path/to/frontend"
      ]
    },
    "cogmemory-backend": {
      "command": "node",
      "args": [
        "/path/to/cogmemory-mcp/dist/index.js",
        "--workspace",
        "/path/to/backend"
      ]
    }
  }
}

O usa una base de datos compartida (todas las raíces en un solo lugar):

{
  "servers": {
    "cogmemory": {
      "command": "node",
      "args": [
        "/path/to/cogmemory-mcp/dist/index.js",
        "--workspace",
        "/shared/root"
      ]
    }
  }
}

O usa el ámbito global para compartir entre todos los espacios de trabajo:

{
  "servers": {
    "cogmemory": {
      "command": "node",
      "args": ["/path/to/cogmemory-mcp/dist/index.js"]
    }
  }
}

export COGMEMORY_SCOPE=global

Referencia de herramientas

Herramientas de memoria

Herramientas del grafo de conocimiento

Herramientas de especificaciones

Herramientas del grafo de código

Arquitectura

cogmemory-mcp/
├── src/
│   ├── index.ts                 # entry point, server bootstrap
│   ├── config.ts                # scope resolution, path resolution
│   ├── types.ts                 # shared TS types mirroring schema
│   ├── db/
│   │   ├── connection.ts        # DB open/close, pragma setup
│   │   ├── schema.sql           # full schema (reference)
│   │   └── migrate.ts           # idempotent schema application
│   ├── tools/
│   │   ├── memory.ts            # decisions/conventions/errors/context/changelog/recall
│   │   ├── plan-tasks.ts        # plan + tasks tools
│   │   ├── sessions.ts          # start/end session, summary
│   │   ├── knowledge-graph.ts   # entities/relations/observations
│   │   ├── specs.ts             # spec CRUD
│   │   ├── code-graph.ts        # index_codebase, query_code_graph
│   │   └── codemap.ts           # generate_codemap, annotate_symbol
│   └── indexing/
│       ├── ts-analyzer.ts       # ts-morph symbol/edge extraction
│       └── walker.ts            # file discovery, gitignore respect
├── schema.sql                   # reference copy
├── package.json
├── tsconfig.json
└── README.md

Esquema (15 tablas)

• Memoria (8): sessions, decisions, conventions, errors, context, changelog, plan, tasks

• Grafo de conocimiento (3): entities, relations, observations

• Especificaciones (1): specs

• Grafo de código (4): symbols, edges, execution_traces, codemap_annotations

Pragmas

Se establecen en cada apertura de conexión:

PRAGMA journal_mode = WAL;
PRAGMA foreign_keys = ON;

Desarrollo

pnpm run dev        # Run with tsx (no build step)
pnpm run build      # Compile TypeScript
pnpm run start      # Run compiled output
pnpm run inspect    # Launch MCP Inspector
pnpm run smoke-test # Run smoke test script

Licencia

MIT