codebase-memory-mcp MCP — Use Cases, Install & Live Demo

Why use it

Key features

Indexes 66 languages via tree-sitter — Linux kernel in 3 minutes
14 MCP tools for graph queries, call tracing, architecture overview, and code search
~99% token reduction vs file-by-file exploration
Single static binary, zero runtime dependencies (macOS, Linux, Windows)
Optional 3D graph visualization UI at localhost:9749

Live Demo

What it looks like in practice

codebase-memory.replay ▶ ready

0/0

Install

Pick your client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "codebase-memory": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/DeusData/codebase-memory-mcp"
      ],
      "_inferred": true
    }
  }
}

Open Claude Desktop → Settings → Developer → Edit Config. Restart after saving.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "codebase-memory": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/DeusData/codebase-memory-mcp"
      ],
      "_inferred": true
    }
  }
}

Cursor uses the same mcpServers schema as Claude Desktop. Project config wins over global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "codebase-memory": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/DeusData/codebase-memory-mcp"
      ],
      "_inferred": true
    }
  }
}

Click the MCP Servers icon in the Cline sidebar, then "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "codebase-memory": {
      "command": "TODO",
      "args": [
        "See README: https://github.com/DeusData/codebase-memory-mcp"
      ],
      "_inferred": true
    }
  }
}

Same shape as Claude Desktop. Restart Windsurf to pick up changes.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "codebase-memory",
      "command": "TODO",
      "args": [
        "See README: https://github.com/DeusData/codebase-memory-mcp"
      ]
    }
  ]
}

Continue uses an array of server objects rather than a map.

~/.config/zed/settings.json

{
  "context_servers": {
    "codebase-memory": {
      "command": {
        "path": "TODO",
        "args": [
          "See README: https://github.com/DeusData/codebase-memory-mcp"
        ]
      }
    }
  }
}

Add to context_servers. Zed hot-reloads on save.

claude mcp add codebase-memory -- TODO 'See README: https://github.com/DeusData/codebase-memory-mcp'

One-liner. Verify with claude mcp list. Remove with claude mcp remove.

Use Cases

Real-world ways to use codebase-memory-mcp

How to quickly understand a new codebase with codebase-memory

👤 Developers onboarding onto an unfamiliar project ⏱ ~15 min beginner

When to use: You just joined a team or started working on a new repo and need to understand its architecture fast.

Prerequisites

codebase-memory installed — curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash

Flow

Index the codebase

Index this project repository and give me an architecture overview.✓ Copied

→ High-level module map with key entry points and dependencies
Explore a specific module

Show me the call graph for the authentication module. What functions does login() call?✓ Copied

→ Call chain from login through middleware, validation, and database
Find related code

Search the graph for all functions that interact with the user table.✓ Copied

→ List of functions with file locations and relationships

Outcome: A solid mental model of the codebase architecture in minutes instead of hours.

Pitfalls

Indexing very large monorepos takes time on first run — Use index_status to check progress. Subsequent queries are instant since the graph persists.

Combine with: filesystem · github

Analyze the impact of a code change before refactoring

👤 Senior engineers planning a refactoring effort ⏱ ~20 min intermediate

When to use: You want to know what will break before you rename, move, or delete a function or class.

Prerequisites

Codebase indexed — Run index_repository first

Flow

Trace all callers

Trace all call paths to the deprecated processPayment() function across the entire codebase.✓ Copied

→ Complete list of callers with file paths and call depths
Map git changes to symbols

I changed these files in my branch. Use detect_changes to show which symbols in the graph are affected.✓ Copied

→ List of affected functions and their downstream dependents

Outcome: A complete impact analysis showing all code that needs to change.

Pitfalls

Graph may be stale if code changed since last index — Re-run index_repository after significant code changes

Combine with: github · filesystem

Combinations

Pair with other MCPs for X10 leverage

codebase-memory + github

Index a repo, then use GitHub MCP to find PRs that affect critical call paths

Index our repo, trace all callers of the auth middleware, then check if any open PRs modify those paths.✓ Copied

codebase-memory + filesystem

Index locally, query the graph, then edit the found files directly

Find all functions that call the deprecated API, then update each one to use the new API.✓ Copied

Tools

What this MCP exposes

Tool	Inputs	When to call
index_repository	path: str	Index a codebase into the knowledge graph (run once, persists)
search_graph	label?: str, pattern?: str	Search the graph by label or pattern
trace_call_path	from: str, to: str	Find call chains between two functions
detect_changes	diff: str	Map git diffs to affected symbols in the graph
get_architecture	project?: str	Get a high-level architecture overview of the indexed codebase
query_graph	query: str	Run a Cypher-like query against the graph
search_code	pattern: str	Grep-style text search across indexed code

Cost & Limits

What this costs to run

API quota: N/A — fully local
Tokens per call: 50–500 tokens per query (vs 2000+ for reading files directly)
Monetary: Free
Tip: Index once, query many times. The graph persists between sessions so you don't re-index.

Security

Permissions, secrets, blast radius

Credential storage: N/A — no external credentials

Data egress: 100% local processing. Your code never leaves your machine.

Binaries are verified via VirusTotal (70+ engines), SLSA Level 3 provenance, Sigstore signatures, and SHA-256 checksums.

Troubleshooting

Common errors and fixes

Indexing fails on large repo

Ensure sufficient disk space for the graph database. For very large repos (>1M LOC), first indexing may take several minutes.

Verify: Check index_status for progress

Language not parsed correctly

Verify your language is in the 66 supported languages. Check tree-sitter grammar availability.

Verify: list_projects to see indexed stats

Graph queries return empty results

The codebase may not be indexed yet. Run index_repository first, then wait for completion.

Verify: index_status

Alternatives

codebase-memory-mcp vs others

Alternative	When to use it instead	Tradeoff
filesystem MCP	You just need to read specific files rather than understand the whole codebase	No graph, no call tracing — but zero setup

More

Resources

📖 Read the official README on GitHub

🐙 Browse open issues

🔍 Browse all 400+ MCP servers and Skills