CogMemory MCP Server

Ein einheitlicher Model Context Protocol-Server, der vier Kontext-Subsysteme für KI-Coding-Agenten bereitstellt:

1. Memory — Entscheidungen, Konventionen, Fehler, aktiver Kontext, Änderungsprotokoll, Plan, Aufgaben, Sitzungen

2. Knowledge Graph — Entitäten, Beziehungen, Beobachtungen

3. Specs — Langdokumente (PRD/SRS), optional mit einer KG-Entität verknüpft

4. Code Graph — statischer Strukturgraph (Symbole/Kanten) + benannte Ausführungsspuren + KI-generierte Annotationen

Speicher: SQLite über better-sqlite3. Eine .db-Datei pro Bereich.

Schnellstart

Installation

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

Konfiguration in VS Code

Fügen Sie zu .vscode/mcp.json hinzu (workspace-bezogen):

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

Oder fügen Sie es zu Ihrem Benutzer-mcp.json hinzu, um es global verfügbar zu machen.

Ausführen mit MCP Inspector (Entwicklung)

pnpm run inspect

Related MCP server: LumenCore

Bereichskonfiguration

CogMemory löst den Bereich in folgender Prioritätsreihenfolge auf:

1. .cogmemory/config.json im Workspace-Root:

   { "scope": "global" }

2. Umgebungsvariable: COGMEMORY_SCOPE=global

3. Standard: workspace

Pfade

Workspace-Auflösung und Multi-Root-Unterstützung

CogMemory löst das Workspace-Root (wo .cogmemory/memory.db liegt) in dieser Prioritätsreihenfolge auf:

1. --workspace <path> CLI-Argument (höchste Priorität)

2. COGMEMORY_WORKSPACE Umgebungsvariable

3. Gehe vom CWD nach oben und suche nach dem nächsten übergeordneten Verzeichnis, das ein .cogmemory/-Verzeichnis enthält

4. Fallback auf CWD

Multi-Root-VS-Code-Workspaces

In einem VS-Code-Multi-Root-Workspace ist jeder Ordner ein separates Workspace-Root. CogMemory behandelt dies wie folgt:

• Single-Root — Funktioniert automatisch. VS Code setzt CWD auf den Workspace-Ordner, und --workspace wird über mcp.json übergeben.

• Multi-Root — Jeder Workspace-Ordner kann ein eigenes .cogmemory/ haben. Weisen Sie jeden mit unterschiedlichen --workspace-Pfaden auf CogMemory zu, oder platzieren Sie ein gemeinsames .cogmemory/ in einem übergeordneten Verzeichnis.

Empfohlenes Multi-Root-mcp.json (pro Ordner):

{
  "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"
      ]
    }
  }
}

Oder verwenden Sie eine gemeinsame Datenbank (alle Roots an einem Ort):

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

Oder verwenden Sie den globalen Bereich, um über alle Workspaces zu teilen:

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

export COGMEMORY_SCOPE=global

Tool-Referenz

Memory-Tools

Knowledge-Graph-Tools

Specs-Tools

Code-Graph-Tools

Architektur

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

Schema (15 Tabellen)

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

• Knowledge Graph (3): entities, relations, observations

• Specs (1): specs

• Code Graph (4): symbols, edges, execution_traces, codemap_annotations

Pragmas

Bei jeder Verbindungsöffnung gesetzt:

PRAGMA journal_mode = WAL;
PRAGMA foreign_keys = ON;

Entwicklung

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

Lizenz

MIT