LatentContext

Session memory, a knowledge graph, a live code index, and stateful code review for any MCP host.

Quick start · Code intelligence · Code review · Memory · Host setup · Configuration · Development

LatentContext is a local Model Context Protocol server. It gives an assistant three things it normally lacks:

• A memory that survives the context window: notes, session summaries, a knowledge graph, and optional local embeddings in SQLite.

• A map of your code: a tree-sitter index of every symbol, call, and reference in the project, kept fresh by file watchers and answered in one tool call.

• A review ledger: plan-driven code review with syntax and security checks, caller impact, verdicts, and step tracking.

Everything runs in-process over stdio. No database server, no native build step, no API keys, and no child processes per tool call.

Tools at a glance

Related MCP server: DataDam Personal Data MCP Server

Highlights

Quick start

npx -y latentcontext-mcp@latest

Most hosts take the same block:

{
  "mcpServers": {
    "latentcontext": {
      "command": "npx",
      "args": ["-y", "latentcontext-mcp@latest"]
    }
  }
}

Restart the host after you change its configuration. Requires Node.js 20 or later.

Code intelligence

code_explore

Ask in whatever form is natural. The tool finds the right symbols and returns their verbatim source with line numbers, so the model can edit from it directly.

code_explore { "query": "how does createServer register tools" }
code_explore { "query": "UserService.load handleRequest" }
code_explore { "query": "src/server.ts" }

A real response for "referencesTo resolveRef" on this repository, trimmed for length:

27 files, 495 symbols indexed.

## src/code-explore.ts
function resolveRef L91-105 · function referencesTo L107-113
91	export function resolveRef(ref: CodeRef): CodeSymbol[] {
92	    const defs = ref.file.index.defsByName.get(ref.name);
93	    if (!defs) return [];
94	    if (defs.size === 1) return [...defs];
⋮
107	function referencesTo(symbol: CodeSymbol): CodeRef[] {
108	    const refs = symbol.file.index.refsByName.get(symbol.name);
109	    if (!refs) return [];
110	    const result: CodeRef[] = [];
111	    for (const ref of refs) if (ref.from !== symbol && resolveRef(ref).includes(symbol)) result.push(ref);
112	    return result.sort((a, b) => Number(b.kind === "call") - Number(a.kind === "call"));
113	}

## Call paths
referencesTo → resolveRef

## References and calls
resolveRef ← referencesTo src/code-explore.ts:111, callees src/code-explore.ts:120
resolveRef → directoryOf src/code-explore.ts:87
referencesTo ← impactOf src/code-explore.ts:212, explore src/code-explore.ts:376

## Impact
6 symbols in 2 files reach resolveRef within 3 hops.

Performance

Measured on Windows 10 with Node.js 24:

An edit is visible on the next call, typically within a few milliseconds.

How it works

flowchart LR
    A[Project files] -->|scan + .gitignore| B(Worker pool)
    B -->|tree-sitter WASM| C[Symbols + references]
    C --> D[(In-memory indexes)]
    D -->|v8 snapshot| E[(Cache on disk)]
    F[File watchers] -->|dirty paths| D
    G[code_explore] --> D
    D --> H[Ranked source + call graph]

1. Scan. A worker walks the project, honours nested .gitignore files, and skips dependency and build caches such as node_modules, .venv, and .next.

2. Parse. Changed files are parsed in parallel by up to eight worker threads. Each language has its own query for definitions, calls, inheritance, imports, and type references.

3. Index. Symbols land in hash maps keyed by exact name, by sub-word (loadUserProfile → load, user, profile), and by reference name. Updates are incremental per file.

4. Rank. Queries are scored by exact and owner-qualified name hits, case-folded matches, IDF-weighted sub-words, prefixes, and file paths.

5. Connect. The top matches are linked by a bounded breadth-first search over the call graph. Intermediate functions on a path are pulled into the result.

6. Render. Source is read fresh from disk, merged into line ranges, and trimmed to the token budget. Large classes are shown as an outline of their members.

Freshness

A .gitignore edit or a large burst of changes, such as a branch switch, triggers one rescan. The index persists to <data dir>/code-index/ and is reused on the next start.

Supported languages

Choosing the project

The project to index is picked in this order:

1. The root argument of the call.

2. LATENTCONTEXT_CODE_ROOT (several paths may be joined with the platform path delimiter).

3. The roots the MCP client reports.

4. The server's working directory, if it looks like a project (.git, package.json, Cargo.toml, go.mod, pyproject.toml, and similar).

The home directory and drive roots are never indexed.

Code review

Four tools run a stateful review against a plan. The model does the judging; the server adds deterministic checks, caller impact from the code index, a verdict, and a ledger that survives restarts.

review_start { "steps": ["Harden path handling", "Remove shell calls"], "profile": "cybersec-auditor-general-v2.0" }
review_chunk { "review_id": "…", "step": 2, "file": "src/run.ts", "code": "…", "findings": [{ "severity": "high", "category": "logic", "message": "Exit code is ignored.", "line": 4 }] }

What review_chunk adds on top of your findings:

• Syntax: tree-sitter parse errors and missing tokens for all 19 indexed languages.

• Security: language-aware rules for eval, shell execution, unsafe deserialization, raw HTML sinks, disabled TLS checks, SQL built by interpolation, unbounded C buffer writes, hardcoded secrets, private keys, and AWS keys.

• Debug leftovers: debugger, pdb.set_trace(), breakpoint(), and dbg!.

• Patch hints: exact search and replace pairs, only where a drop-in fix exists (for example yaml.load( → yaml.safe_load(, or a hardcoded JS secret → process.env.NAME).

• Context: for each symbol the chunk defines (or the symbol you name), its references, first callers, and impact from the code index.

Any critical or high finding makes the verdict NEEDS_WORK and keeps the step IN_PROGRESS; otherwise the step is VALIDATED. A review is COMPLETED when every step is validated. Finding lines are relative to the chunk; context lines are relative to the file. Reviews expire 7 days after their last update.

Review lenses

A lens is a Markdown prompt that sets what the review looks for. Four ship with the package: universal-auditor-general-v3 (the default), cybersec-auditor-general-v2.0, performance-reliability-auditor-v2.0, and design-audit-director-v2.0. The profile argument is an enum of the available lenses, so hosts show them without an extra tool. Set LATENTCONTEXT_REVIEW_PROFILES to a directory of *.md files to use your own; the file name is the ID and the first # heading is the title.

Memory

Stored notes need at least 10 words; 25 or more are recommended. Working memory is isolated by session ID, and it is archived when a session changes or the server shuts down.

session_start, memory_store, memory_retrieve, memory_status, code_explore, review_start, review_chunk, and review_status return structuredContent that matches a published outputSchema.

extract_facts, compress_session, and consolidate_epoch are prompt templates. They turn text into fact triples, summarize working memory, and merge session summaries.

Host setup

claude mcp add latentcontext --scope user -- npx -y latentcontext-mcp@latest

Use --scope project to share the configuration through .mcp.json.

Add the mcpServers block from Quick start to claude_desktop_config.json (Settings → Developer → Edit Config).

Add the mcpServers block to .cursor/mcp.json in the project, or to ~/.cursor/mcp.json for all projects.

Create .vscode/mcp.json:

{
  "servers": {
    "latentcontext": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "latentcontext-mcp@latest"]
    }
  }
}

Add the mcpServers block to ~/.codeium/windsurf/mcp_config.json.

Add to ~/.codex/config.toml:

[mcp_servers.latentcontext]
command = "npx"
args = ["-y", "latentcontext-mcp@latest"]

Add the mcpServers block to ~/.gemini/settings.json, or to .gemini/settings.json in the project.

Configuration

Environment variables

Storage

Runtime state is project-local by default:

<launched-project>/.latentcontext/
├── .gitignore      # "*" so the folder never reaches git
├── memory.db
├── server.log
└── code-index/

<launched-project> is the working directory of the server process. The folder ignores itself, so no repository needs a .gitignore entry for it. To share memory across projects, set LATENTCONTEXT_DATA_DIR:

{
  "mcpServers": {
    "latentcontext": {
      "command": "latentcontext-mcp",
      "env": { "LATENTCONTEXT_DATA_DIR": "C:/shared/latentcontext" }
    }
  }
}

Point LATENTCONTEXT_CONFIG at a JSON file:

{
  "storage": { "dataDir": "./shared-state", "sqliteFile": "memory.db" },
  "embedding": { "provider": "local" }
}

A relative storage.dataDir resolves against the configuration file. The server also reads latentcontext.config.json from the default data directory or beside the installed package. A latentcontext.config.json in the launched project is ignored unless LATENTCONTEXT_ALLOW_PROJECT_CONFIG=1 is set. Use "provider": "none" to disable embeddings.

Logging

Diagnostics go to server.log in the data directory. After the MCP handshake, records at info and above are also sent as notifications/message with logger latentcontext. Clients can change the threshold with logging/setLevel. Stdout carries only protocol frames, and nothing is written to stderr.

Development

git clone https://github.com/Master0fFate/LatentContext-MCP.git
cd LatentContext-MCP
npm install
npm run build

To run a local build from a host, point it at the entry point:

{
  "mcpServers": {
    "latentcontext": {
      "command": "node",
      "args": ["/absolute/path/to/LatentContext-MCP/dist/index.js"]
    }
  }
}

CI runs on Linux, macOS, and Windows with Node.js 20, 22, and 24.

Grammars for TypeScript, TSX, JavaScript, Python, Rust, Go, Java, C#, C++, Ruby, PHP, Bash, and PowerShell come from @vscode/tree-sitter-wasm. The C, Kotlin, Scala, Lua, Zig, and Elixir grammars in grammars/ are the prebuilt WebAssembly files published with tree-sitter-c 0.24.1, @tree-sitter-grammars/tree-sitter-kotlin 1.1.0, tree-sitter-scala 0.24.0, @tree-sitter-grammars/tree-sitter-lua 0.4.1, @tree-sitter-grammars/tree-sitter-zig 1.1.2, and tree-sitter-elixir 0.3.5.

License

MIT