DeusData/codebase-memory-mcpPublic

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

AI summary: MCP server providing instant semantic codebase indexing and graph querying for AI agents.

Stars
48.9K
+199 today
Forks
4.1K
Watchers
168
Open issues
503
Open PRs
66
Contributors
~226
Commits
5.6K
Branches
651

CMITCreated Feb 24, 2026Last push 1d agoLatest release v0.12.1+337 stars this week+1.8K this month

Quick answers

What is codebase-memory-mcp?
MCP server providing instant semantic codebase indexing and graph querying for AI agents.
What does codebase-memory-mcp do?
This tool indexes massive codebases in milliseconds using advanced tree-sitter AST analysis and a hybrid LSP implementation for precise semantic type resolution. It creates a persistent, highly structured knowledge graph of functions, classes, HTTP routes, and architectural decisions locally on your machine. By acting as an MCP server, it allows advanced AI coding agents like Claude Code or Cursor to query this complex graph instantly without relying on slow file-by-file text searches. This architectural approach significantly reduces expensive token usage and dramatically improves the structural accuracy of AI-generated code.
Who is codebase-memory-mcp for?
This tool is for software engineers and AI tool users working with large, complex codebases who need highly accurate context retrieval. It requires standard build tools and compatibility with MCP clients.
How do I get started with codebase-memory-mcp?
curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash
How popular is codebase-memory-mcp on GitHub?
DeusData/codebase-memory-mcp has 48,943 stars and 4,070 forks on GitHub, and gained 337 stars in the last 7 days.
What license does codebase-memory-mcp use?
DeusData/codebase-memory-mcp is released under the MIT license.

Star history

since Jul 27, 2026
020K40KJul 2026Sep 2026Oct 2026Nov 2026
48.9K stars as of Nov 21, 2026. Measured daily since Jul 27, 2026; GitHub no longer exposes earlier star timestamps.

Update history

4 recorded
  • Oct 27, 2026New release v0.12.1 (previously v0.12.0).
  • Oct 21, 2026Description changed from "High-performance code intelligence MCP server. Indexes codebases into a persistent knowledge graph — average repo in mil" to "Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with ".
  • Oct 16, 2026New release v0.12.0 (previously v0.11.0).
  • Oct 16, 2026Description changed from "High-performance code intelligence MCP server. Indexes codebases into a persistent knowledge graph — average repo in mil" to "High-performance code intelligence MCP server. Indexes codebases into a persistent knowledge graph — average repo in mil".

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 0 commits2026-02-14: 0 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 0 commits2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 18 commits2026-02-26: 4 commits2026-02-27: 2 commits2026-02-28: 12 commits2026-03-01: 9 commits2026-03-02: 5 commits2026-03-03: 4 commits2026-03-04: 0 commits2026-03-05: 1 commit2026-03-06: 17 commits2026-03-07: 6 commits2026-03-08: 0 commits2026-03-09: 0 commits2026-03-10: 0 commits2026-03-11: 0 commits2026-03-12: 11 commits2026-03-13: 3 commits2026-03-14: 1 commit2026-03-15: 3 commits2026-03-16: 0 commits2026-03-17: 10 commits2026-03-18: 28 commits2026-03-19: 33 commits2026-03-20: 26 commits2026-03-21: 42 commits2026-03-22: 10 commits2026-03-23: 12 commits2026-03-24: 15 commits2026-03-25: 31 commits2026-03-26: 16 commits2026-03-27: 6 commits2026-03-28: 10 commits2026-03-29: 2 commits2026-03-30: 5 commits2026-03-31: 2 commits2026-04-01: 1 commit2026-04-02: 21 commits2026-04-03: 15 commits2026-04-04: 4 commits2026-04-05: 2 commits2026-04-06: 18 commits2026-04-07: 1 commit2026-04-08: 0 commits2026-04-09: 0 commits2026-04-10: 2 commits2026-04-11: 2 commits2026-04-12: 11 commits2026-04-13: 0 commits2026-04-14: 3 commits2026-04-15: 17 commits2026-04-16: 6 commits2026-04-17: 0 commits2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 0 commits2026-04-21: 0 commits2026-04-22: 1 commit2026-04-23: 0 commits2026-04-24: 0 commits2026-04-25: 1 commit2026-04-26: 0 commits2026-04-27: 0 commits2026-04-28: 0 commits2026-04-29: 0 commits2026-04-30: 5 commits2026-05-01: 0 commits2026-05-02: 4 commits2026-05-03: 0 commits2026-05-04: 5 commits2026-05-05: 5 commits2026-05-06: 0 commits2026-05-07: 0 commits2026-05-08: 26 commits2026-05-09: 48 commits2026-05-10: 9 commits2026-05-11: 0 commits2026-05-12: 0 commits2026-05-13: 0 commits2026-05-14: 0 commits2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 0 commits2026-05-18: 0 commits2026-05-19: 4 commits2026-05-20: 1 commit2026-05-21: 14 commits2026-05-22: 0 commits2026-05-23: 0 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 3 commits2026-05-27: 0 commits2026-05-28: 3 commits2026-05-29: 14 commits2026-05-30: 31 commits2026-05-31: 39 commits2026-06-01: 20 commits2026-06-02: 2 commits2026-06-03: 10 commits2026-06-04: 1 commit2026-06-05: 13 commits2026-06-06: 35 commits2026-06-07: 12 commits2026-06-08: 16 commits2026-06-09: 20 commits2026-06-10: 8 commits2026-06-11: 7 commits2026-06-12: 27 commits2026-06-13: 12 commits2026-06-14: 6 commits2026-06-15: 0 commits2026-06-16: 2 commits2026-06-17: 3 commits2026-06-18: 1 commit2026-06-19: 1 commit2026-06-20: 7 commits2026-06-21: 2 commits2026-06-22: 12 commits2026-06-23: 9 commits2026-06-24: 11 commits2026-06-25: 4 commits2026-06-26: 40 commits2026-06-27: 40 commits2026-06-28: 59 commits2026-06-29: 8 commits2026-06-30: 9 commits2026-07-01: 17 commits2026-07-02: 15 commits2026-07-03: 25 commits2026-07-04: 26 commits2026-07-05: 18 commits2026-07-06: 34 commits2026-07-07: 26 commits2026-07-08: 17 commits2026-07-09: 18 commits2026-07-10: 12 commits2026-07-11: 14 commits2026-07-12: 26 commits2026-07-13: 17 commits2026-07-14: 6 commits2026-07-15: 3 commits2026-07-16: 13 commits2026-07-17: 5 commits2026-07-18: 51 commits2026-07-19: 31 commits2026-07-20: 0 commits2026-07-21: 3 commits2026-07-22: 5 commits2026-07-23: 28 commits2026-07-24: 3 commits2026-07-25: 48 commits2026-07-26: 34 commits2026-07-27: 30 commits2026-07-28: 16 commits2026-07-29: 14 commits2026-07-30: 12 commits2026-07-31: 17 commits2026-08-01: 10 commits2026-08-02: 12 commits2026-08-03: 38 commits2026-08-04: 22 commits2026-08-05: 6 commits2026-08-06: 23 commits2026-08-07: 10 commits2026-08-08: 21 commits2026-08-09: 27 commits2026-08-10: 13 commits2026-08-11: 9 commits2026-08-12: 14 commits2026-08-13: 52 commits2026-08-14: 25 commits2026-08-15: 11 commits2026-08-16: 15 commits2026-08-17: 14 commits2026-08-18: 15 commits2026-08-19: 11 commits2026-08-20: 21 commits2026-08-21: 14 commits2026-08-22: 6 commits2026-08-23: 5 commits2026-08-24: 26 commits2026-08-25: 3 commits2026-08-26: 11 commits2026-08-27: 38 commits2026-08-28: 45 commits2026-08-29: 27 commits2026-08-30: 15 commits2026-08-31: 9 commits2026-09-01: 8 commits2026-09-02: 15 commits2026-09-03: 10 commits2026-09-04: 14 commits2026-09-05: 21 commits2026-09-06: 12 commits2026-09-07: 11 commits2026-09-08: 27 commits2026-09-09: 15 commits2026-09-10: 9 commits2026-09-11: 7 commits2026-09-12: 8 commits2026-09-13: 15 commits2026-09-14: 12 commits2026-09-15: 2 commits2026-09-16: 5 commits2026-09-17: 2 commits2026-09-18: 10 commits2026-09-19: 11 commits2026-09-20: 29 commits2026-09-21: 8 commits2026-09-22: 11 commits2026-09-23: 4 commits2026-09-24: 9 commits2026-09-25: 55 commits2026-09-26: 32 commits2026-09-27: 9 commits2026-09-28: 35 commits2026-09-29: 19 commits2026-09-30: 28 commits2026-10-01: 11 commits2026-10-02: 76 commits2026-10-03: 107 commits2026-10-04: 97 commits2026-10-05: 61 commits2026-10-06: 28 commits2026-10-07: 16 commits2026-10-08: 4 commits2026-10-09: 7 commits2026-10-10: 40 commits2026-10-11: 56 commits2026-10-12: 26 commits2026-10-13: 27 commits2026-10-14: 30 commits2026-10-15: 5 commits2026-10-16: 7 commits2026-10-17: 14 commits2026-10-18: 45 commits2026-10-19: 37 commits2026-10-20: 60 commits2026-10-21: 22 commits2026-10-22: 9 commits2026-10-23: 2 commits2026-10-24: 1 commit2026-10-25: 10 commits2026-10-26: 7 commits2026-10-27: 8 commits2026-10-28: 13 commits2026-10-29: 8 commits2026-10-30: 3 commits2026-10-31: 15 commits2026-11-01: 27 commits2026-11-02: 29 commits2026-11-03: 5 commits2026-11-04: 6 commits2026-11-05: 5 commits2026-11-06: 0 commits2026-11-07: 4 commits2026-11-08: 1 commit2026-11-09: 4 commits2026-11-10: 7 commits2026-11-11: 14 commits2026-11-12: 7 commits2026-11-13: 9 commits2026-11-14: 9 commits2026-11-15: 0 commits2026-11-16: 0 commits2026-11-17: 0 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
3,641 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    48,943 stars

  • Very active

    3,641 commits in 52 weeks

  • Community-driven

    ~226 contributors

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    29 trending appearances

What codebase-memory-mcp does

This tool indexes massive codebases in milliseconds using advanced tree-sitter AST analysis and a hybrid LSP implementation for precise semantic type resolution. It creates a persistent, highly structured knowledge graph of functions, classes, HTTP routes, and architectural decisions locally on your machine. By acting as an MCP server, it allows advanced AI coding agents like Claude Code or Cursor to query this complex graph instantly without relying on slow file-by-file text searches. This architectural approach significantly reduces expensive token usage and dramatically improves the structural accuracy of AI-generated code.

This tool is for software engineers and AI tool users working with large, complex codebases who need highly accurate context retrieval. It requires standard build tools and compatibility with MCP clients.

  • AST-based indexing: Utilizes tree-sitter to parse code into a precise abstract syntax tree for semantic understanding.
  • Hybrid LSP integration: Resolves complex type relationships and variable scopes using language server protocols.
  • Persistent knowledge graph: Maintains a local, structured database of codebase architecture for instant querying.
  • MCP server architecture: Exposes the index directly to compatible AI agents via standard Model-Context-Protocol.
  • Token-efficient retrieval: Eliminates the need to load entire files into context by returning targeted structural data.

Where teams use it

Large Codebase Navigation

Developers working on enterprise monorepos who need their AI assistant to instantly understand global architectural dependencies.

Context-Aware Code Generation

Engineers relying on AI to generate complex features that require deep knowledge of existing internal APIs and type definitions.

Token Optimization

Teams looking to reduce API costs by providing AI agents with highly targeted architectural graphs instead of full text dumps.

Automated Refactoring

Agents tasked with executing large-scale refactors that require a perfect understanding of function call graphs and references.

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

README

main branch

codebase-memory-mcp: local code intelligence for AI agents via MCP

GitHub Release License CI Native and frontend tests MCP tools Languages Hybrid LSP Agents Pure C Platform OpenSSF Scorecard SLSA 3 VirusTotal arXiv Join the community on Discord

Understand your repository, from source code to the systems around it. codebase-memory-mcp is an MCP server that connects code, documentation, configuration, and infrastructure in a persistent local knowledge graph. Use it to find an unfamiliar feature, follow a call across services, trace a deployment back to its source, or assess which parts of a project a change could affect.

Give your coding agent structural context through Model Context Protocol (MCP), or query the graph directly from the CLI. The MCP server is the core of the project. Its optional visual companion, CBM Lens, is in open beta (v0.0.1), with a source reader, architecture maps, the Galaxy graph, coverage diagnostics, architecture decisions, and local code chat.

The native C backend exposes 17 MCP tools, parses languages and file formats with vendored grammars, and adds Hybrid LSP type resolution for supported languages. The installer supports 46 automatic or conditional client integrations, including client configuration, skills, agent profiles, and applicable hooks. Indexing and graph queries need no hosted service or API key. Focused graph queries can reduce repeated file reads and token use; see the measured results.

Quick start · Capabilities · Documentation · Infrastructure · Smart CI · Explore CBM Lens · Agent setup · MCP tools

Local processing: Source analysis and graph storage run on your machine. CBM Lens can optionally download a model for browser AI after you enable it; inference stays on the device. The installer writes agent configuration for the clients you select. See Security for release verification and SECURITY.md for reporting issues.

See the graph with CBM Lens (open beta v0.0.1). Folders become nested platforms, files and symbols become selectable blocks, and arrows show indexed relationships. The recording opens src/foundation in the map of this repository, selects arena.c and opens its source. Height can show source size; hotspot gravity reflects static fan-in. Still image.

CBM Lens Beta architecture walkthrough: open src/foundation, select arena.c and read its source beside the map

Galaxy. Explore the code knowledge graph in 3D. The recording follows the outgoing relationships of cbm_arena_alloc one layer further, switches to the hierarchy and shows the two-hop call path to cbm_alloc. Edge pulses show relationship direction; they do not represent live execution. Still: two dependency layers around cbm_max_file_bytes.

Code knowledge graph in CBM Lens Beta Galaxy: expand cbm_arena_alloc, switch to the hierarchy and follow its call path through arena_grow to cbm_alloc

Explore. Browse files in an IDE-style workspace, read syntax-highlighted source in Monaco, and keep the code graph alongside it. File impact shows what depends on the open file, and Code details shows the callers and calls of the symbol under the caret. Select code to ask the local chat about it.

CBM Lens Beta Explore: limits.c in the source reader beside its file impact summary and direct graph dependencies

More views: system structure and behavior

System structure groups symbols into components and lets you inspect their dependencies.

CBM Lens Beta system structure: source groups of this repository with their dependencies, src selected

Behavior shows possible calls from a selected operation and the source evidence behind them.

CBM Lens Beta Behavior view: the possible direct calls of compileCards and its declaration

The high-resolution GIFs show CBM Lens Beta on 20 October 2026; the still images were captured on 12–13 October. All show public source from this repository. See capture details for each capture's build, indexed scope and recording setup.

Why codebase-memory-mcp

  • Find the right code with context: combine symbol, text, and semantic search with callers, dependencies, source snippets, and file outlines. Targeted queries and compact, paged results can reduce token use and repeated file reads; see Performance for scoped measurements.
  • Connect documentation to implementation: index document sections, PDF text pages, architecture decisions, and supported references into code. Find the explanation alongside the symbol.
  • Follow the system beyond source files: trace supported relationships through Docker, Kubernetes, Helm, Kustomize, Terraform/OpenTofu, Terragrunt, Ansible, scripts, Make, and CI configuration.
  • Understand a change before running it: inspect affected symbols, compare indexed snapshots, and find related tests. Experimental Smart CI combines static relationships and per-test coverage for supported C/C++ test harnesses, falling back to broader runs when evidence is insufficient.
  • Explore visually with CBM Lens Beta: read source, follow call paths, inspect architecture and coverage gaps, manage architecture decisions, and ask a local model about selected code.
  • Equip your coding agents: install sets up supported client configuration, durable guidance, skills, Scout/Verify/Auditor profiles, and applicable context hooks. Support varies by client; see the integration matrix.
  • Keep context local and reusable: indexes persist between sessions, eligible active MCP sessions can keep them synchronized, and optional graph artifacts let a team share a baseline.
  • Run a native tool on your machine: standard releases include CBM Lens for macOS, Linux, and Windows. The native runtime needs no Docker or language runtime; parser grammars are included.

Quick Start

Install the latest release (macOS / Linux):

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

The standard native release includes CBM Lens. Start it after installation with codebase-memory-mcp daemon start --open --port=9749. The Nix packages and source builds also offer builds without the UI.

Windows (PowerShell):

# 1. Download the installer
Invoke-WebRequest -Uri https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.ps1 -OutFile install.ps1

# 2. (Optional but recommended) Inspect the script
notepad install.ps1

# 3. Unblock the downloaded file (removes Mark-of-the-Web restriction added by browsers/Invoke-WebRequest)
Unblock-File .\install.ps1

# 4. Run it
.\install.ps1

Note: If you see a script execution policy error, run Set-ExecutionPolicy -Scope Process Bypass first, or invoke with PowerShell -ExecutionPolicy Bypass -File .\install.ps1.

Options: --skip-config (binary only, no agent setup), --dir=<path> (custom location).

Antivirus note: Microsoft Defender may flag a release binary as Trojan:Script/Wacatac.B!ml. This is a known false positive; typically 61 of ~62 engines return clean, and the same detection family hits gh, llama.cpp, Godot and Microsoft's own Go toolchain. See Antivirus False Positives for the evidence, how to verify the artifacts yourself, and how to report it if you think we are wrong.

Restart your coding agent. Say "Index this project": done.

Manual install
  1. Download the archive for your platform from the latest release:

    • codebase-memory-mcp-<os>-<arch>.tar.gz (macOS/Linux) or .zip (Windows)
  2. Extract and install (each archive includes install.sh or install.ps1):

    macOS / Linux:

    tar xzf codebase-memory-mcp-*.tar.gz
    ./install.sh

    Windows (PowerShell):

    Expand-Archive codebase-memory-mcp-windows-amd64.zip -DestinationPath .
    Unblock-File .\install.ps1
    .\install.ps1
  3. Restart your coding agent.

The install command automatically strips macOS quarantine attributes and ad-hoc signs the binary; no manual xattr/codesign needed.

Agent setup: skills, profiles, and hooks

Installation also equips supported coding agents to use the graph in daily work. The native install command detects clients and installs the integration pieces their documented formats support:

Component What it adds
MCP configuration Connects the client to the local server and its tools.
Instructions and skills Explains graph-first exploration, index freshness, coverage checks, and when to read source.
Scout, Verify, and Auditor profiles Offers fast provisional lookup, task-directed verification, or bounded full verification, where custom agents are supported.
Session and compaction hooks Restores graph context at supported lifecycle events.
Search and read hooks Adds relevant graph context to supported searches and flags recorded coverage gaps after supported file reads.

Hook augmentation is context-only and fail-open: it does not replace or block the requested tool call. Features vary by client and platform; some clients use durable instructions or a parent-agent handoff instead of hooks or direct subagent MCP access. Codex users review and trust installed hooks through /hooks. See Multi-Agent Support and Sessions, compaction, and subagents for exact support and activation requirements.

Hooks are enabled by default. Run codebase-memory-mcp install --no-hooks to remove CBM-managed hooks while keeping MCP registration and other integration files; the choice persists for later installs and updates. Run codebase-memory-mcp install --hooks to re-enable them, or inspect the current preference with codebase-memory-mcp config get install_hooks.

Session Coordination Daemon

CBM automatically shares one per-account coordination daemon across Claude Code, Codex, OpenCode, and every other configured client. There is no opt-in setting for MCP servers or hook clients: the first daemon-backed CBM session starts it, each session registers its own work, and a session-managed daemon stops after the final session. A daemon started with daemon start remains running until stopped. The daemon owns long-lived background services such as watchers, shared indexing jobs, and the optional UI. Closing one session cancels work owned only by that session, while work still needed by another session continues.

The detached daemon does not depend on an MCP frontend's stderr. It keeps owner-only durable records under the canonical ${CBM_CACHE_DIR}/logs directory (default ~/.cache/codebase-memory-mcp/logs):

File Contents
cbm-daemon.log Daemon lifecycle, watcher/indexing, UI, resource, and error events.
daemon-conflicts.ndjson Exact-build, coordination-ABI, and cache-root admission conflicts.
activation-events.ndjson Install/update/uninstall activation progress and outcomes.

Thin frontends still write immediate startup and session-specific errors to their own stderr; MCP JSON-RPC stdout remains clean.

All active CBM processes must run the exact same version, executable build, coordination ABI, and canonical cache root. Equivalent CBM_CACHE_DIR aliases resolve to the same root; a genuinely different root is rejected while any CBM process is active. MCP servers, hooks, one-shot CLI commands, temporary index workers, and the daemon share a crash-safe OS admission barrier; starting an ordinary conflicting process fails before doing work and records an explicit conflict in ${CBM_CACHE_DIR}/logs/daemon-conflicts.ndjson.

The native install and uninstall commands are the deliberate exception to that conflict rule. For installation, download, verification, and private same-filesystem staging finish before activation so a bad candidate never disrupts active work. The native update command prints the installer command that performs the update. Activation then publishes account-wide maintenance intent, asks the daemon and every temporary local operation to cancel, and waits to a finite deadline for all coordinated CBM processes to exit. It holds the admission and lifetime barriers exclusively while changing the active binary, configuration, PATH, or indexes. New CBM work cannot enter during this window. Activation progress and results are recorded in ${CBM_CACHE_DIR}/logs/activation-events.ndjson, and a successful command tells you to restart open coding-agent sessions so they launch the activated build.

Package-manager setup (npm, PyPI, or Go) verifies and caches the native executable for that package. It does not replace the active native installation and therefore does not stop running CBM sessions. When that cached binary is executed, it still enters the same exact-build admission barrier. The shell and PowerShell installers invoke the verified candidate's native install command, so they do receive the full account-wide activation guarantee.

The ordinary cli mode runs one command locally, but it is not disconnected from the daemon above: it connects to the shared coordination daemon (starting one if none is already running) for that same admission barrier plus per-project locks on graph mutations. Its connection is a cli_session: it does not register a project watcher or open a browser, and it holds the admission lease only for the command's lifetime. The shared daemon may serve Lens according to its UI configuration and available assets. If the command's own connection is what started the daemon, that daemon exits again once the command closes and no other session is attached; if a daemon was already running, the command simply joins and leaves it exactly as found. While the command is running, a temporary monitor separately lets activation cancel that operation and its supervised worker safely; the monitor exits with the command and never becomes a standing daemon. See CLI Mode for details.

CBM Lens Beta: code visualization and source navigation

CBM Lens is an optional visual companion to the MCP server, currently in open beta (v0.0.1). Standard native releases include its browser interface, so you can launch Lens directly after installation; UI-enabled source builds include it too. It builds on CodeAtlasWeb by Bernhard Jackiewicz (design and tracking in #1964). Lens is served on loopback. Browser AI downloads its optional model only after you enable it; inference stays on-device. Each panel names where its facts come from, and what the index did not record is shown as a gap. Start the local server:

codebase-memory-mcp daemon start --open --port=9749

The browser opens at http://127.0.0.1:9749. A permanent daemon keeps the UI available after the command exits. Use daemon status to inspect it and daemon stop when you are finished. For an MCP session, --ui=true --port=9749 enables the same shared UI. Active clients must use the same executable build and cache directory.

Open your first repository

  1. Open the project menu and choose Add project index. You can also use Alt+P.
  2. Choose a local repository folder and name the index. Files stay in place.
  3. Start indexing and follow its reported status. You can close the dialog while it runs and reopen its activity from the project menu.
  4. Open the indexed project. Start with Architecture for an overview or Explore to read a file.

To bookmark a view, use ?project=<name>&workspace=architecture. Other workspace values are explore, galaxy, adr, coverage, and system.

Workspace What you can do
Explore Navigate the indexed file tree and read source in Monaco. File impact shows what depends on the open file; Code details shows the callers, calls, references and related tests of the symbol under the caret.
Galaxy Search and focus graph nodes, load their neighbors layer by layer, switch to hierarchy, follow a path, and open source. Back and Forward return to earlier views. The coverage shadow marks known gaps around the loaded graph.
Architecture Explore the folder map, entry points, routes, hotspots, system structure, and behavior paths. Select a node or connection to inspect its evidence.
ADR Read and edit the project's architecture decision record. Save explicitly; the document is stored with the index and shared with manage_adr.
Coverage Check indexed, partially parsed, skipped, and excluded paths, together with available freshness information.
System Inspect daemon activity, indexes, and logs. Filter logs by project, severity, or text.

Architecture views

  • Overview: move through source folders and files on a 3D map. Choose source-size or uniform height, language or kind colors, and relationship filters. Switch to Entry points to follow a static call graph from a starting symbol.
  • Routes: switch between the service map and endpoint connections. Deployment metadata and indexed route evidence are shown separately; unresolved registrations remain visible.
  • Hotspots: inspect symbols using measured signals such as fan-in and complexity. Gravity wells help locate frequently referenced areas. They are not a code-quality score.
  • System structure: inspect component dependencies, expand groups, isolate cycles, and follow connections back to source evidence.
  • Behavior: choose a source and a reachable destination to inspect static call paths and their source statements. These paths show possible relationships, not a recorded execution order. Runtime observations require separately ingested traces.

Drag a 3D view to orbit, scroll to zoom, and select a node or edge to inspect it. Edge colors distinguish relationships, and pulses indicate their direction. Reduced-motion preferences pause the pulses. Large views show their limits and omitted counts. A missing edge can reflect an indexing or display limit, so check Coverage and the source before drawing conclusions.

Chat with your codebase locally

Open Chat with the panel button at the top right to ask about the code you are looking at. In Explore it uses the open file or the exact text you have selected; in Galaxy it uses the selected node and its loaded neighbors. You can also attach graph evidence through Add context.

  1. Click the robot icon at the top right to open the agent configuration.
  2. Choose a local model. The default Qwen2.5 Coder 0.5B downloads about 567 MB; Qwen3 0.6B, LFM2.5 1.2B and Qwen3.5 2B are larger options. All need WebGPU with shader-f16 support.
  3. Click Download & load. Model files come from Hugging Face; inference runs in your browser, with no hosted chat API or API key. A model that is already in the browser cache loads with Load model (cached, no download).
  4. Ask a question. The composer shows the file or selection that will accompany it. Select a smaller range when you want to focus the answer.

Questions about callers and callees, such as "Who calls cbm_pipeline_run?", are answered from the loaded graph without the model, and the answer says so. When you select a symbol, the chat lists its indexed facts and the lines of its code, and the model adds one sentence; that sentence is left out when it claims something the source does not show. Text written by the model is labelled as such.

The recording asks who calls arena_grow and what it calls, with both answers listed directly from the indexed graph beside the selected symbol. Still image of a model explanation and graph answer.

Chat with your codebase locally in CBM Lens Beta: callers and callees of arena_grow answered directly from the indexed graph

The chat history is kept for 24 hours in this browser, per project. Each new message uses the source currently open in the reader; earlier source snapshots are not silently accumulated, and messages about another file or selection are not sent along. If a prompt is too long for the model, older messages are left out first; if it still does not fit, CBM Lens asks you to select less code instead of cutting the code. This chat explains the context you give it; it cannot edit files or run tools. Check its answers against the source. The small default model words things loosely, especially in languages other than English.

Search

Cmd+K or Ctrl+K opens the Galaxy search. It finds symbols, files and folders by name or path in the whole index, also nodes that are not loaded yet. For callers and callees, ask in the chat; the answer is listed from the graph.

Architecture decisions

The ADR workspace keeps an unsaved draft per project in this browser tab. It checks whether the stored document changed before saving, but the API does not provide an atomic document lock. The editor accepts up to 8,000 UTF-8 bytes. Saving changes the indexed decision document, not a file in your repository.

Experimental agent activity

The Agents workspace and activity overlays are hidden in normal builds. To include them in a source build:

VITE_EXPERIMENTAL_AGENTS=true scripts/build.sh --with-ui

Activity comes from explicitly configured tool hooks. The bundled adapter supports Claude Code PostToolUse; other clients need their own adapter. Recorded events go to the local daemon, and the reader must enable activity before the browser polls them. This does not automatically observe every agent. See the frontend setup guide.

For troubleshooting, open System logs. Frontend errors and failed requests are recorded locally. GET /api/ui-log reads frontend entries from the daemon's SQLite journal; ${CBM_CACHE_DIR}/logs/ui.log is also retained as a rotating JSONL export. See the frontend README for log scope, model setup, and development details.

Auto-Index

Enable automatic indexing on MCP session start:

codebase-memory-mcp config set auto_index true

auto_index is off by default. When enabled, new projects are indexed automatically on first connection. The configurable file limit is config set auto_index_limit 50000. Previously indexed projects can be watched through auto_watch (on by default), subject to its global setting and session ownership.

Each initialized, long-lived MCP session can register its root project when it connects and any target from a successful index_repository call, including custom project names and roots in another worktree. While auto_watch is enabled, these watches belong to the registering sessions and remain while at least one owning session is connected; closing the last owner removes the watch. Under a daemon started with daemon start a watch outlives its last owning session: the project stays watched and is re-indexed in the background when it changes, until that daemon stops, the project is deleted, its directory disappears, or auto_watch is set to false. An async index registers its target only after success and while its requesting session remains connected. CLI indexing and failed MCP indexes do not register watches. Global auto_watch controls registration and removes all watches on the next refresh or registration request when set to false. index_status reports this in its watch object: watched, and either the poll cadence and last scan time or the reason it is not watched.

Watcher registration is controlled globally by auto_watch (default true). On the next refresh or registration request, true allows MCP sessions to register their root on connect and their successful index_repository targets; false removes all watches. CLI indexing and failed MCP indexes do not add watches.

To turn the watcher off entirely, set config set watcher_enabled false (default true): the background poll thread never starts and no project is registered, while auto_index and manual index_repository keep working. Unlike auto_watch, which takes effect on the next refresh or registration request, watcher_enabled is read once when the background daemon starts, so run codebase-memory-mcp daemon stop after changing it; reconnecting your MCP client alone will not restart the daemon. See docs/CONFIGURATION.md.

The watcher follows git projects only by default: a project indexed from a directory that is not a git repository is not watched and stays at its last index until you run index_repository again. To have such roots polled too, set config set watch_non_git true (default false, read when the daemon starts): they are then checked on the same cadence with a file-tree scan that uses the indexer's own ignore rules.

Linked git worktrees are indexed as their own projects by default. Set config set ignore_worktrees true to skip them on the automatic paths — useful when short-lived git worktree add checkouts would otherwise each leave behind a permanent index of the same repository. An explicit index_repository call on a worktree is then refused unless you pass index_worktree=true. See docs/CONFIGURATION.md.

Keeping Up to Date

Updates run from the install script on every platform, not from inside the running binary. codebase-memory-mcp update validates your flags and then prints the exact command to run:

# macOS / Linux
bash "<install-dir>/install.sh"
# Windows
powershell -File "<install-dir>\install.ps1"

The install script is placed next to the binary at install time, so the printed path resolves beside the executable. It is idempotent, so re-running it is the update: it stops the daemon, retires the running binary, installs the new one, and cleans up.

Why it works this way. On Windows it is a hard requirement; a running executable cannot replace its own image, so the swap has to happen from a process that is not the binary being replaced. On macOS and Linux it is a deliberate choice: an in-process updater is structurally a downloader (fetch an archive, verify it, unpack it, mark a file executable, run it), and shipping that composite in every binary to serve a command most people run a handful of times is a poor trade. The release archives now carry no download URLs at all, and cbm makes no network request of its own accord: it does not check for new versions in the background, and nothing phones home. You find out about releases from the install script, your package manager, or GitHub.

If PowerShell refuses to run the script because the file came from the internet, Unblock-File it first.

Installed through npm or pip? Update with your package manager on every platform (npm install -g codebase-memory-mcp@latest / pip install -U codebase-memory-mcp).

Uninstall

codebase-memory-mcp uninstall

Removes owned agent config entries, skills, hooks, instructions, and the installed binary. Existing graph indexes are listed and kept by default. -y/--yes, -n/--no, and noninteractive input keep them unless --delete-indexes is explicitly given. An interactive terminal without that flag is asked separately; the default answer is to keep them.

codebase-memory-mcp uninstall -y --delete-indexes   # also delete every project index
codebase-memory-mcp uninstall --dry-run --delete-indexes   # preview; change nothing

--delete-indexes is explicit consent and takes precedence over --no; --dry-run always preserves the files. When indexes are kept, uninstall prints their cache directory (${CBM_CACHE_DIR:-~/.cache/codebase-memory-mcp}) and how to remove them.

The install script placed beside the binary is reported, not deleted: uninstall prints its path and the rm command for it. It is left alone on purpose: it may be your own copy, a symlink into a checkout, or managed by a package manager, and an uninstaller should not delete a file it cannot prove it owns.

Features

Graph & analysis

  • Architecture overview: get_architecture returns a compact summary by default. Request specific aspects for routes, hotspots, dependencies, clusters, or cycles. system_structure provides the projection used by CBM Lens and must be requested on its own.
  • Architecture Decision Records: manage_adr persists the project's decision record across sessions; indexing also extracts supported ADR metadata and supersession from documentation files
  • Louvain community detection: Discovers functional modules by clustering call edges
  • Change impact: detect_changes maps uncommitted changes to affected symbols with risk classification and can report test impact with scope: "tests"; compare_graphs compares indexed snapshots
  • Runtime observations: ingest_traces adds observed call relationships from separately collected traces alongside static analysis; static call paths alone do not show what ran
  • Call graph: Resolves function calls across files and packages (import-aware, type-inferred)
  • Dead code candidates: find functions with no indexed callers, excluding entry points. Check dynamic dispatch, coverage gaps, and framework conventions before removing code.
  • Cypher-like queries: MATCH (f:Function)-[:CALLS]->(g) WHERE f.name = 'main' RETURN g.name

Search

  • Semantic search (the semantic_query parameter of search_graph, not a separate tool): vector search across the entire graph, powered by bundled Nomic nomic-embed-code embeddings (40K tokens, 768d int8) compiled into the binary; no API key, no Ollama, no Docker. 11-signal combined scoring (TF-IDF, RRI, API/Type/Decorator signatures, AST profiles, data flow, Halstead-lite, MinHash, module proximity, graph diffusion).
  • BM25 full-text search via SQLite FTS5 with cbm_camel_split tokenizer (camelCase / snake_case aware)
  • Structural search (search_graph): regex name patterns, label filters, min/max degree, file scoping
  • Code search (search_code): graph-augmented grep over indexed files only

Documentation connected to code

Find the explanation behind a symbol and follow supported references back to its implementation. Documentation participates in the graph alongside source files:

  • Markdown, reStructuredText, and AsciiDoc become navigable document sections; PDFs with text layers become searchable text pages. PDF extraction does not perform OCR.
  • Document-to-code references and supported language doc-comment references create MENTIONS relationships when the target can be resolved.
  • Architecture decision records contribute metadata such as status, deciders, and supersession, so decisions can be explored with the code they describe.
  • Supported diagrams and OpenAPI descriptions contribute structured entities. Extraction and reference resolution differ by format; not every textual mention becomes a graph edge.

Use graph and text search to locate the relevant section, follow its recorded relationships, and open the source evidence. Check check_index_coverage before treating a missing result as proof that the repository has no such documentation or reference.

Infrastructure and deployment

Ask "What deploys this service?", "Which image runs it?", or "Where does this configuration reach code?" CBM connects supported infrastructure forms to the source they build, configure, and run:

  • Containers and clusters: Dockerfiles, Compose services, Kubernetes resources, Helm charts and releases, and Kustomize overlays and patches.
  • Provisioning and configuration: Terraform/OpenTofu resources and modules, tfvars overrides, Terragrunt dependencies, Ansible tasks and handlers, and supported configuration keys and environment-variable access.
  • Build and delivery: shell commands, Make targets, and supported CI steps that build images, invoke repository scripts, or deploy resources.

For resolvable inputs, a trace can follow Service → workload → image → Dockerfile → program, or follow deployment and configuration relationships. Use trace_path modes for topology, deployment, and run paths. These are static relationships from supported source forms; dynamic values and unresolved templates can leave gaps. See Edge types for the exact relationship rules and limitations.

Cross-service linking

  • HTTP route ↔ call-site matching with confidence scoring
  • gRPC, GraphQL, tRPC service detection with protobuf Route extraction
  • Channel detection (EMITS / LISTENS_ON) for Socket.IO, EventEmitter, and generic pub-sub patterns across 8 languages with constant resolution

Cross-repo intelligence

  • CROSS_* edges link nodes across multiple repos indexed under the same store
  • Cross-repo architecture summary combining services, routes, and dependencies across the indexed fleet
  • Run status: index_status (and the UI layout next to linked_projects) carries a cross_repo object, {"status":"never_run"} until index_repository(mode="cross-repo-intelligence") has run with that project as the source, then "ran" with last_run_at, outcome, targets, projects_scanned, total_cross_edges and skipped_projects. That is how you tell "never linked" apart from "linked, nothing matched". The status is stored in the project's own index next to its CROSS_* edges, so a reindex that rebuilds the index drops both at once and the status goes back to never_run.
  • Skipped stores: target_projects: ["*"] skips an index built before the #768 schema change rather than failing the whole run. The response lists each one as skipped_projects: [{"name", "reason": "pre_768_schema", "hint": "reindex this project"}].

Smart CI and test impact

Use the graph to explain which tests a change reaches, and use that evidence to focus supported CI runs. Smart CI is experimental and has two layers:

Layer What it does What you supply
CI job selection Chooses jobs from the changed-file list. Repository-specific path and job rules; this repository's selector is an example.
Test selection Combines static reachability, changed tests, and admitted per-test coverage to select suites or tests. A supported C/C++ test harness, configuration, a coverage map, and a runner that accepts named selections.

codebase-memory-mcp test-impact select produces a selection with reasons; test-impact publish produces the graph-and-coverage bundle used as its baseline. For agent-assisted investigation, detect_changes with scope: "tests" exposes test impact through MCP.

Narrowing currently supports C/C++ family code with this repository's test conventions or declared equivalents. It is not general test selection for every language CBM indexes. Missing, stale, incompatible, or incomplete evidence broadens the selection or returns run_all; static reachability without admitted coverage never omits a suite. Begin with report-only shadow mode and validate your harness before enabling gating.

In this repository, test narrowing is on for every PR unless TEST_IMPACT_MODE says otherwise: the Linux x86_64 test leg runs the selection, and the arm64, macOS and Windows legs run it with every platform-specific suite whole; release and dry-run workflows retain full execution. See the Smart CI guide for supported conventions, coverage admission, setup, version requirements, and fallback behavior.

Edge types (selected)

  • CALLS: a callable is invoked at the source site
  • CALL_REFERENCE: a callable is used at a supported reference site (for example, a direct value argument) and resolves to one exact target
  • USAGE: an identifier is used, but a unique callable target is not proven (including ambiguous or complex expressions)
  • IMPORTS, DEFINES, IMPLEMENTS, INHERITS
  • HTTP_CALLS, ASYNC_CALLS (cross-service); a shell script, Make recipe or CI step running curl / wget on a URL it states (constant words resolved, unknown parts {}) to its Route with the method its flags give: a Kubernetes Service of the repository by the path, as code clients do, any other host (a download, localhost) with the host kept; the edge keeps via, method, url_path, host, never the user info or the query
  • SPAWNS: the caller starts another program (subprocess.run, exec.Command, posix_spawn, Process.Start, a shell command or Make recipe running a program by path, ...); the target is a Process node named after the program, or <dynamic> when the program is not a literal. When a shell script, Make recipe, GitHub Actions step or Prow job runs a script of the repository (./hack/x.sh, bash hack/x.sh), the target is that script's Module (else its File); make TARGET (also $(MAKE), -C, -f) targets the rule of that target, followed through included makefiles; edges from CI carry ci and job. A Dockerfile's last stage ENTRYPOINT (else CMD) spawns what the container runs (api: dockerfile): the repository script or source copied into the image, the Go main of a binary a stage builds with go build -o, else a Process
  • INFRA_MAPS: a Kubernetes Service to each workload whose pod labels carry every key: value of the Service's selector, within one namespace
  • CONNECTS_TO: a Kubernetes workload or compose service to the Service its containers' environment addresses (PRODUCT_CATALOG_SERVICE_ADDR: productcatalogservice:3550, a URL's host, <svc>.<ns>.svc..., a bare name on an *_ADDR / *_HOST / *_URL / ... key; compose: the project's .env interpolated): a Kubernetes Service of the same bundle and namespace, or a compose service of the same file. The edge keeps via: env, key and container, never the value
  • USAGE with ref: image: a Kubernetes workload (any pod template: containers, initContainers, CronJobs, custom resources) or a docker compose service to the Image it runs
  • Helm templates are rendered for their images: with the chart's values (the Chart DEPLOYS them, default_of: the values keys read) and with each release's (a Flux HelmRelease, a kustomize helmCharts entry, a Terraform helm_release: override_of). An image the render cannot know is left out, never guessed: after a change of values it does not run exactly, a tpl or include it cannot look into, a release value it cannot read, or a work budget it runs past. Known limit: each template file renders on its own, while Helm renders a chart's files with one shared .Values (a subchart's is its parent's .Values.<alias>), so a chart that changes .Values in one file and reads it in another can still show a wrong image
  • DEPLOYS: what puts manifests, kustomizations or charts on a cluster, to what it puts there: a Flux Kustomization or Argo Application to the kustomizations / manifests / chart of its path, a Flux HelmRelease to its chart (spec.chart or chartRef → OCIRepository), a shell command or Make recipe (kubectl apply -f/-k, kustomize build | kubectl apply, helm install/upgrade/template), a Go installer loading a chart with the Helm SDK, a Terraform helm_release, a Terraform kubernetes_* resource the object it declares (a Resource like a manifest's, ecosystem: terraform, when its name is a literal), a kustomization inflating a chart (helmCharts; its values file an IMPORTS). A chart outside the repository is an external Chart, keyed by its publisher when its repository URL is stated (__chart__<repository>/<name>, the same node in every project, the URL in repository), else one per project and name; the edge says via (flux, argo, helmrelease, kubectl, kustomize, helm, helm-sdk, terraform, helmcharts, ...)
  • DEPENDS_ON: a Helm chart to the charts it declares (the local chart for a resolvable file:// repository, otherwise an external Chart; the edge keeps repository), and a go.mod / requirements.txt file to an external Package; a Dockerfile to the Images it builds on (via: from, copy-from); an Image to the Dockerfile it is built from (via: build; tool: skaffold, compose, docker-build for docker / podman / nerdctl / buildah build commands in scripts, Make and CI); a compose service to the services its depends_on / links name
  • CONFIGURES: code reading an environment variable to the shared EnvVar of that name (strategy: env_access); a Kubernetes container, compose service or Dockerfile (ENV of the image) setting one to that container's own EnvVar (strategy: env_set, with source: value, configMapKeyRef, secretKeyRef, fieldRef, ..., compose, dockerfile; values are never stored); and that container's EnvVar to the code reading the name inside the files its image is built from (strategy: env_read, with dockerfile): the image's files are the sources its Dockerfile's COPY / ADD put into it, less the context's .dockerignore
  • CONFIGURES with strategy: key_symbol: a code symbol to the config key it names (config_key). A YAML, JSON, HCL (Terraform, OpenTofu, tfvars), TOML or INI key links by exact name (maxRetryCount = max_retry_count) and only to code inside the config file's component: its directory, or the one around a config/, configs/, conf/, settings/ or etc/ directory. A .env or .properties key also links by substring (confidence 0.75)
  • OVERRIDE with via: patch: a Kustomize patch to each object of its kustomization's build it changes (child → base): a patch file's documents to the object of the same kind and name; an inline patch (from the kustomization) or a JSON6902 operation file to what its target selects (group, version, kind, name, namespace, label selector); a component's in the build of each kustomization including it. The edge keeps kustomization, patch and line; a patch file is an IMPORTS (local_name: patches) of its kustomization, never a member of the build
  • OVERRIDE with via: namePrefix / nameSuffix: an object a kustomization renames, from its variant: a Resource named with the deployed name (capi- + controller-manager; the prefixes of nested kustomizations outermost first, suffixes innermost first) in the namespace that build gives it, ecosystem: kustomize, which the kustomization's file DEFINES. CRDs, Namespaces and API services keep their names, as kustomize does. The edge keeps kustomization and line
  • USAGE with via: terraform: a Terraform / OpenTofu reference (var.X, local.X, module.X, data.T.N, T.N) from the top-level block holding it to the block of its module (the .tf / .tofu files of its directory) that declares it (a locals entry: its locals block); an entry of the block's depends_on list is a DEPENDS_ON instead. The edge keeps ref (var, local, module, data, resource) and line; a name only mentioned in string text is no reference. A module call with a local source (module "net" { source = "./modules/net" }) IMPORTS (local_name: the module's name) the Folder of that directory (the root directory: the Project), and module.net.id (also module.net[0].id, module.net[*].id) USAGEs (ref: output) the output "id" there, beside module.net
  • OVERRIDE with via: tfvars: a .tfvars assignment to a variable the module of its own directory declares, from the file's Variable to that variable block (the edge keeps line); a .tfvars file whose own directory declares none of its names sets the nearest ancestor module's that does, the edge marked inferred (such a file is applied by a -var-file the repository does not state)
  • Terragrunt (via: terragrunt): a unit (terragrunt.hcl), evaluated in its own context: an include IMPORTS (local_name) the file its path names; a read_terragrunt_config IMPORTS (read: the file holding the call) the file it names, from the block holding the call or, for a call in an included file, from the unit's include block that brings it in; a dependency DEPENDS_ON the other unit; a local terraform source IMPORTS its Folder. Paths may use find_in_parent_folders, dirname and get_terragrunt_dir; anything else is unknown and links nothing
  • Ansible (via: ansible): a playbook or task file (a YAML file whose top level is a sequence) IMPORTS (local_name: the directive) what its directives name: import_playbook a playbook, include_tasks / import_tasks / include a task file (from its directory, else its role's tasks/), roles: items and include_role / import_role a role's Folder (roles/<name> at or above its directory). A templated target links nothing. Each task and handler is a Function (named by its name:, else its module; source: ansible, kind, module) that its file DEFINES: in a playbook's plays, a role's tasks/ and handlers/ files, and the files those include; a block's tasks, not the block. A notify CALLS (via: notify) each handler of that name or listen topic in the task's own role (else its file). A kube (kubespray's module) or kubernetes.core.k8s task DEPLOYS (via: ansible, module) the repository file its play rendered the applied manifest from: the template (in the role's templates/) or copy (its files/) task whose dest is the task's filename, item by item through register / with_items / loop lists the play states (a literal list, a set_fact, the role's defaults / vars), or a k8s template: argument
  • EMITS, LISTENS_ON (channels)
  • DATA_FLOWS with arg-to-param mapping + field access chains
  • SIMILAR_TO (MinHash + LSH near-clone detection, Jaccard scored)
  • SEMANTICALLY_RELATED (vocabulary-mismatch, same-language, score ≥ 0.80)

Indexing pipeline

  • 164 vendored tree-sitter grammars compiled into the binary
  • Generic package / module resolution: bare specifiers like @myorg/pkg, github.com/foo/bar, use my_crate::foo resolved via manifest scanning (package.json, go.mod, Cargo.toml, pyproject.toml, composer.json, pubspec.yaml, pom.xml, build.gradle, mix.exs, *.gemspec)
  • Infrastructure-as-code indexing: Dockerfiles (Dockerfile.*, *.Dockerfile, Containerfile: bases, what the container runs, ENV), container images (Image: the normalised repository, tag and digest on the edges; a repository built from several Dockerfiles, one per component tag, gets an Image per component), docker compose services (Resource), Kubernetes manifests (Resource, with group, version, kind, namespace, labels as k=v,k2=v2), Kustomize overlays (IMPORTS to their entries and patch files, OVERRIDE from their patches), Helm charts (Chart, DEPENDS_ON), Terraform / OpenTofu (.tf, .tofu, .tfvars) as graph nodes. A Service walks to the code it runs: Service → workload → Image → Dockerfile → main
  • Hybrid LSP semantic type resolution for Python, TypeScript / JavaScript / JSX / TSX, PHP, C#, Go, C, C++, Java, Kotlin, Rust, and Perl; a lightweight C implementation of language type-resolution algorithms, structurally inspired by and compatible with major language servers including tsserver / typescript-go, pyright, gopls, Roslyn, Eclipse JDT, and rust-analyzer (parameter binding, return-type inference, generic substitution, JSX component dispatch, JSDoc inference for plain JS files, namespace + trait + late-static-binding resolution for PHP, file-scoped namespaces + records + LINQ method syntax for C#, class-hierarchy + overload + lambda resolution for Java, extension-function + scope-function resolution for Kotlin, trait-method + UFCS resolution for Rust)
  • RAM-first pipeline: LZ4 compression, in-memory SQLite, single dump at end. Memory released after.

Distribution & operation

  • Native runtime set, zero infrastructure services: SQLite-backed, persists to ~/.cache/codebase-memory-mcp/
  • Auto-sync: Background watcher detects file changes in projects registered by active MCP sessions, including successful explicit index_repository targets, and re-indexes them automatically.
  • Route nodes: REST endpoints are first-class graph entities
  • CLI mode: codebase-memory-mcp cli search_graph --project my-project --name-pattern ".*Handler.*"
  • Available on: npm, PyPI, Homebrew, Scoop, AUR, go install

Indexing modes

Mode Use it for
full Full indexing with semantic analysis. This is the default.
moderate A filtered index with semantic analysis.
fast A filtered index without semantic analysis.
cross-repo-intelligence Link services across indexed projects, optionally limited by target_projects.

Team-Shared Graph Artifact

Share a compressed graph snapshot so teammates can reuse an indexed baseline.

.codebase-memory/graph.db.zst is a zstd-compressed snapshot of the knowledge graph that lives next to your source. The artifact is opt-in: index_repository writes it only with persistence: true (the default is false), and once it exists later indexes refresh it. Local indexes persist regardless. When a teammate indexes a clone with an existing artifact, CBM imports that baseline and applies their local changes incrementally.

  • Format: SQLite database, indexes stripped, VACUUM INTO compacted, then zstd 1.5.7 compressed (8 to 13:1 ratio typical)
  • Two tiers:
    • Best (zstd -9 + index strip + VACUUM INTO); written by index_repository with persistence: true
    • Fast (zstd -3); refreshes an existing artifact on every other index, including the watcher's low-latency incremental updates
  • Bootstrap: when no local DB exists but the artifact is present, index_repository imports the artifact first, then runs incremental indexing, reusing the shared baseline where possible
  • Merge policy: the first export creates .codebase-memory/.gitattributes with merge=ours. Check your repository's Git merge-driver setup before relying on it for concurrent artifact updates.
  • Commit it deliberately: the artifact is rewritten on every index, including the watcher's Fast tier, and git stores each rewrite as a full new blob. Committing every refresh is what turns a 20 MB file into gigabytes of history; one team reached ~6 GB across ~350 commits of this single path. Pick a cadence (a release, a milestone, a nightly job) rather than committing every save.
  • Git LFS, if it must move on every commit: track it from the repo-root .gitattributes and leave the auto-created .codebase-memory/.gitattributes in place; the nearer file goes on supplying merge=ours, and only filter comes from the root:
    .codebase-memory/graph.db.zst filter=lfs diff=lfs merge=lfs -text
    Track only the .zst; artifact.json is small and carries the schema version. The attribute applies to future commits only. Removing existing blobs requires a separate history migration. Two costs to weigh before adopting it: GitHub meters LFS storage and bandwidth, and its objects cannot be pruned without contacting support; and every teammate needs git lfs install; without it their checkout leaves a pointer file where the artifact should be, the integrity-checked import refuses it, and they fall back to a full reindex.
  • Optional: shared export is opt-in, and Git commits remain your choice. Add .codebase-memory/ to .gitignore if you prefer everyone to reindex from scratch.

The artifact provides a shared baseline while each developer keeps a local query database.

How It Works

codebase-memory-mcp is a structural analysis backend: it builds and queries the knowledge graph. The backend does not require a generative model. It relies on your MCP client (Claude Code, or any MCP-compatible agent) to be the intelligence layer.

You: "what calls ProcessOrder?"

Agent calls: trace_path(function_name="ProcessOrder", direction="inbound")

codebase-memory-mcp: executes graph query, returns structured results

Agent: presents the call chain in plain English

With MCP, your coding agent translates a question into tool calls. CBM Lens can also use an optional browser model for explanations; this does not change how the backend indexes or queries code.

Performance

Published backend benchmarks on Apple M3 Pro. These are separate from the CBM Lens checks:

Operation Time Notes
Linux kernel full index 3 min 28M LOC, 75K files → 4.81M nodes, 7.72M edges
Linux kernel fast index 1m 12s 1.88M nodes
Django full index ~6s 49K nodes, 196K edges
Cypher query <1ms Relationship traversal
Name search (regex) <10ms SQL LIKE pre-filtering
Dead code detection ~150ms Full graph scan with degree filtering
Trace call path (depth=5) <10ms BFS traversal

Memory-aware pipeline: Indexing keeps hot data in memory and can spill extraction results to disk when needed. Memory is released back to the OS after indexing completes.

More focused context, fewer tokens: The project's 31-repository preprint reports 10× lower token use and 2.1× fewer tool calls compared with file-by-file exploration. These March 2026 backend measurements cover the study's workloads and agent setup; the paper documents the full evaluation. An earlier five-query comparison reported ~3,400 versus ~412,000 tokens for structural queries. The study's system-performance measurements include the Linux indexing and Cypher timings above.

Explore the measurement guide to evaluate quality, latency and token use on your own workload.

Troubleshooting & Diagnostics

codebase-memory-mcp indexes and queries locally and collects no telemetry. When you hit something we can't reproduce on our side (a slow memory climb over hours, a performance regression, a leak that only appears after days of real use), we have no diagnostic data unless you choose to send it. Here is how to capture it yourself.

Capture a diagnostics log

Set CBM_DIAGNOSTICS=1 before the first daemon-backed MCP session starts, then reproduce the problem (let it run as long as it takes; a slow leak needs time to show in the trend). The shared daemon captures this setting from the session that starts it. If it is already running, close all daemon-backed sessions so it exits before changing the setting. The daemon creates a fresh owner-private cbm-diagnostics-<pid>-<random> directory below the system temp directory ($TMPDIR or /tmp on macOS/Linux, %TEMP% on Windows). The exact paths are recorded by the diagnostics.start event in ${CBM_CACHE_DIR}/logs/cbm-daemon.log:

File What it is
trajectory.ndjson The memory trajectory: one JSON line every 5 s with rss, committed (Windows commit charge), peak_*, page_faults, fd, and queries. This is the file we need for memory/leak reports: the trend over time is what pinpoints a leak. It is kept on disk after the server exits (so you can grab it post-mortem) and rotates to trajectory.ndjson.1 past ~8 MB.
snapshot.json The latest snapshot only; handy for a quick live check. Removed on clean exit.

The private randomized directory prevents another local account from pre-placing a link or special file at a predictable diagnostics path. Its <pid> component is the shared daemon's process ID, also recorded by the daemon.start event. Set the variable consistently in the env block of each agent's MCP server config, or export it before launching the first session.

What to share

When you open a memory/performance issue, attach the .ndjson trajectory: it contains no source code or query text, only resource counters. If you'd rather not attach a file, paste it (or an agent's summary of it) into the issue: your assistant can read the NDJSON directly and report whether rss/committed grow monotonically, how fast, and relative to query count; which is exactly what we need to find the cause.

Installation

Pre-built Binaries

Platform Archive
macOS (Apple Silicon) codebase-memory-mcp-darwin-arm64.tar.gz
macOS (Intel) codebase-memory-mcp-darwin-amd64.tar.gz
Linux (x86_64) codebase-memory-mcp-linux-amd64.tar.gz
Linux (ARM64) codebase-memory-mcp-linux-arm64.tar.gz
Windows (x86_64) codebase-memory-mcp-windows-amd64.zip

Every release includes checksums.txt with SHA-256 hashes. The executable is self-contained; no adjacent data file is required. Linux -portable archives contain the fully static builds; ordinary platform archives use their native system ABI.

Windows note: SmartScreen may show a warning for unsigned software. Click "More info" → "Run anyway". Verify integrity with checksums.txt.

Setup Scripts

Automated download + install

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/scripts/setup.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/scripts/setup-windows.ps1 | iex

AUR (Arch Linux)

yay -S codebase-memory-mcp-bin
paru -S codebase-memory-mcp-bin

The codebase-memory-mcp-bin package is available at: https://aur.archlinux.org/packages/codebase-memory-mcp-bin

Nix (flake)

The flake exposes two server packages plus the standalone frontend:

(README truncated)

View on GitHub

Recent activity

commits and pull requests

Releases and announcements

49 total
  1. v0.12.1v0.12.1Oct 16, 2026250.5K downloads

    # v0.12.1 **Every install path works again, and Helm charts join the graph.** v0.12.1 fixes v0.12.0's package installs and the other install paths we found broken while checking every channel. It also links Helm charts to what they deploy, and stops the graph from inventing a registry for container images. > **Upgrading?** The first index of each existing project after the upgrade is a full rebuild, once (image identities changed; see below). ## Fixed: installs - **npm, PyPI and Go installs.** `npm i`, `pnpm add`, `pip install` and the Go wrapper could not install v0.12.0 on any platform. Each wrapper refused an archive member above 256 MiB, and every v0.12.0 binary is 331-335 MB. The size limits are gone from all three wrappers. The archive is still verified against the release's `checksums.txt` before it is unpacked, its contents must be exactly the expected files, and the binary must answer `--version`. Thank you, @hydroplexus, for the precise report (#2657). - **Homebrew.** The formula was still at 0.10.3, and on Linux it installed the dynamically linked build, which needs glibc 2.38 (Ubuntu 22.04, Debian 12 and RHEL 9 do not have it). It now installs the current release,

  2. v0.12.0v0.12.0Oct 15, 202649.3K downloads

    # v0.12.0 **Meet CBM Lens, and a code graph that reads your documentation.** v0.12.0 is the biggest release of codebase-memory-mcp yet: 231 merged pull requests since v0.11.0, 40 of them from the community. Four headlines define it. 1. **CBM Lens Beta: the code graph, for humans.** Until now the graph's power reached people only through their agents. Lens is our new human interface. It brings the code knowledge graph to you directly. It ships inside the binary you already run and listens on loopback only. It puts source, the graph, the architecture, index coverage and a browser-local assistant side by side, and every fact it shows says where it comes from. Lens is built on the work of @BernhardJackiewicz, who now joins the project to own it. 2. **Documentation joins the graph.** Until now the graph stopped where the code stopped. Now doc comments, Markdown, reStructuredText, AsciiDoc and PDF documents, architecture decision records, diagrams and OpenAPI specs are part of it. Each is linked to the functions, types and files it talks about. An agent can now traverse your documentation and land on the exact code a page describes, and walk from a function back to every page that e

  3. v0.11.0v0.11.0Sep 15, 2026295.5K downloads

    # v0.11.0 A large release, and an unusually community-heavy one: **171 pull requests** merged since v0.10.8 (9 of them dependency bumps), **76 of them from contributors outside the maintainer**. Thank you — this release is mostly your work. It is a minor version rather than another 0.10.x patch because the index format moves (one rebuild, below) and the tool output contract changes. The reason v0.11.0 exists is install, uninstall and daemon-startup reliability, and memory: if cbm ever refused to install, refused to uninstall cleanly, died at startup without telling you why, or blew through the memory budget on a large repository, this is the release to take. Two things to know before you upgrade, and one thing you will notice. ## Highlights ### The first run after upgrading rebuilds your index once This is expected. It is not an error, and nothing is lost. PR #1104 (`feb72080`, by **@LA-10**) completes the File-node change from #1108: a File node's qualified name now keeps its file extension, so `auth.py` and `auth.ts` in the same directory are finally distinct nodes instead of colliding on one name. That moves the on-disk index format boundary, so an index built by v0.10.8

  4. v0.10.8v0.10.8Aug 19, 2026360.7K downloads

    # v0.10.8 > **Note on v0.10.7:** this release supersedes v0.10.7, which was lost to a release-pipeline > publishing error (published under the tag `0.10.7` instead of `v0.10.7`; package installers > resolve the v-prefixed tag, and release immutability makes the name unrecoverable). The npm > and PyPI 0.10.7 packages are deprecated/yanked for that reason — their binaries were fine, > their download URLs were not. v0.10.8 carries the identical code content plus the pipeline > hardening that prevents a recurrence. A community-heavy patch release: 19 pull requests merged since v0.10.6, most from contributors. Thank you all! ## Graph correctness - **Cypher aggregates no longer undercount** (#1196). Both truncation mechanisms are fixed: unlabeled scans stopped collecting candidates at max_rows *before* aggregation ran (#1323, @Enferlain), and relationship-expansion buffers were capped so aggregation never saw rows beyond an internal growth limit (#1698). `count()`/`collect()` now see the complete match set; `max_rows` limits only the rows returned, as documented. - **Python aliased from-imports resolve to the real definition** (#1371, @Joseph-MingEn). `from .gate import exe

  5. 0.10.70.10.7Aug 18, 2026pre-release2.5K downloads

    > [!WARNING] > **Broken for npm/PyPI installs — superseded by v0.10.8.** A publishing error released this under the tag `0.10.7` instead of `v0.10.7`. The npm/PyPI package installers resolve their downloads via the v-prefixed tag, which cannot be created retroactively (release immutability tombstones the name). **Direct downloads from this page work normally** — the binaries themselves are fine and fully verified. Use **v0.10.8** or newer for package-manager installs, or `scripts/setup.sh`. ## What's Changed * fix(extract): converge Function/Method is_test with the tests/ path filter by @Yyunozor in https://github.com/DeusData/codebase-memory-mcp/pull/1308 * fix(hooks): scope pre-commit clang-tidy to staged changes (#1264) by @Yyunozor in https://github.com/DeusData/codebase-memory-mcp/pull/1310 * fix(mcp): isolate semantic-only JSON search by @JJordan0C in https://github.com/DeusData/codebase-memory-mcp/pull/1319 * fix(search): preserve compound requested fields by @Enferlain in https://github.com/DeusData/codebase-memory-mcp/pull/1325 * fix(cypher): scan all unlabeled query candidates by @Enferlain in https://github.com/DeusData/codebase-memory-mcp/pull/1323 * fix(registry): dro

Code frequency

additions and deletions
+20.2M-20.2MWeek of 2026-02-22: +31,490 linesWeek of 2026-02-22: -3,195 linesWeek of 2026-03-01: +20,154,582 linesWeek of 2026-03-01: -16,658 linesWeek of 2026-03-08: +77,667 linesWeek of 2026-03-08: -814 linesWeek of 2026-03-15: +555,261 linesWeek of 2026-03-15: -150,077 linesWeek of 2026-03-22: +22,579 linesWeek of 2026-03-22: -5,086 linesWeek of 2026-03-29: +151,029 linesWeek of 2026-03-29: -37,557 linesWeek of 2026-04-05: +88,562 linesWeek of 2026-04-05: -105,552 linesWeek of 2026-04-12: +15,090,470 linesWeek of 2026-04-12: -1,494,450 linesWeek of 2026-04-19: +44 linesWeek of 2026-04-19: -6 linesWeek of 2026-04-26: +604 linesWeek of 2026-04-26: -97 linesWeek of 2026-05-03: +104,675 linesWeek of 2026-05-03: -10,598 linesWeek of 2026-05-10: +12,078 linesWeek of 2026-05-10: -40 linesWeek of 2026-05-17: +10,233 linesWeek of 2026-05-17: -549 linesWeek of 2026-05-24: +3,797 linesWeek of 2026-05-24: -3,970 linesWeek of 2026-05-31: +7,338,807 linesWeek of 2026-05-31: -4,772,316 linesWeek of 2026-06-07: +54,440 linesWeek of 2026-06-07: -1,691,048 linesWeek of 2026-06-14: +5,460 linesWeek of 2026-06-14: -299 linesWeek of 2026-06-21: +2,067,972 linesWeek of 2026-06-21: -1,560 linesWeek of 2026-06-28: +791,546 linesWeek of 2026-06-28: -2,423 linesWeek of 2026-07-05: +20,630 linesWeek of 2026-07-05: -6,499 linesWeek of 2026-07-12: +176,056 linesWeek of 2026-07-12: -21,913 linesWeek of 2026-07-19: +22,854 linesWeek of 2026-07-19: -2,739 linesWeek of 2026-07-26: +30,232 linesWeek of 2026-07-26: -31,320 linesWeek of 2026-08-02: +35,725 linesWeek of 2026-08-02: -5,108 linesWeek of 2026-08-09: +33,902 linesWeek of 2026-08-09: -19,376 linesWeek of 2026-08-16: +17,167 linesWeek of 2026-08-16: -1,652 linesWeek of 2026-08-23: +1,756,075 linesWeek of 2026-08-23: -467,260 linesWeek of 2026-08-30: +269,175 linesWeek of 2026-08-30: -21,512 linesWeek of 2026-09-06: +78,309 linesWeek of 2026-09-06: -3,729 linesWeek of 2026-09-13: +35,574 linesWeek of 2026-09-13: -4,369 linesWeek of 2026-09-20: +1,276,278 linesWeek of 2026-09-20: -680,406 linesWeek of 2026-09-27: +157,666 linesWeek of 2026-09-27: -7,646 linesWeek of 2026-10-04: +111,665 linesWeek of 2026-10-04: -8,833 linesWeek of 2026-10-11: +59,621 linesWeek of 2026-10-11: -13,239 linesWeek of 2026-10-18: +30,480 linesWeek of 2026-10-18: -9,392 linesWeek of 2026-10-25: +6,017 linesWeek of 2026-10-25: -946 linesWeek of 2026-11-01: +4,763 linesWeek of 2026-11-01: -1,156 linesFeb 22, 2026Nov 1, 2026
+50.7M lines added, -9.6M removed over the last year.

Commits per week

last 52 weeks
2850Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 36 commitsWeek of 2026-03-01: 42 commitsWeek of 2026-03-08: 15 commitsWeek of 2026-03-15: 142 commitsWeek of 2026-03-22: 100 commitsWeek of 2026-03-29: 50 commitsWeek of 2026-04-05: 25 commitsWeek of 2026-04-12: 37 commitsWeek of 2026-04-19: 2 commitsWeek of 2026-04-26: 9 commitsWeek of 2026-05-03: 84 commitsWeek of 2026-05-10: 9 commitsWeek of 2026-05-17: 19 commitsWeek of 2026-05-24: 51 commitsWeek of 2026-05-31: 120 commitsWeek of 2026-06-07: 102 commitsWeek of 2026-06-14: 20 commitsWeek of 2026-06-21: 118 commitsWeek of 2026-06-28: 159 commitsWeek of 2026-07-05: 139 commitsWeek of 2026-07-12: 121 commitsWeek of 2026-07-19: 118 commitsWeek of 2026-07-26: 133 commitsWeek of 2026-08-02: 132 commitsWeek of 2026-08-09: 151 commitsWeek of 2026-08-16: 96 commitsWeek of 2026-08-23: 155 commitsWeek of 2026-08-30: 92 commitsWeek of 2026-09-06: 89 commitsWeek of 2026-09-13: 57 commitsWeek of 2026-09-20: 148 commitsWeek of 2026-09-27: 285 commitsWeek of 2026-10-04: 253 commitsWeek of 2026-10-11: 165 commitsWeek of 2026-10-18: 176 commitsWeek of 2026-10-25: 64 commitsWeek of 2026-11-01: 76 commitsWeek of 2026-11-08: 51 commitsWeek of 2026-11-15: 0 commitsNov 23, 2025Nov 15, 2026
3.6K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 43 commitsSun 1:00 — 27 commitsSun 2:00 — 18 commitsSun 3:00 — 15 commitsSun 4:00 — 11 commitsSun 5:00 — 8 commitsSun 6:00 — 10 commitsSun 7:00 — 15 commitsSun 8:00 — 9 commitsSun 9:00 — 18 commitsSun 10:00 — 12 commitsSun 11:00 — 10 commitsSun 12:00 — 24 commitsSun 13:00 — 43 commitsSun 14:00 — 54 commitsSun 15:00 — 28 commitsSun 16:00 — 44 commitsSun 17:00 — 33 commitsSun 18:00 — 58 commitsSun 19:00 — 42 commitsSun 20:00 — 36 commitsSun 21:00 — 39 commitsSun 22:00 — 32 commitsSun 23:00 — 19 commitsMon 0:00 — 43 commitsMon 1:00 — 36 commitsMon 2:00 — 34 commitsMon 3:00 — 17 commitsMon 4:00 — 17 commitsMon 5:00 — 13 commitsMon 6:00 — 14 commitsMon 7:00 — 7 commitsMon 8:00 — 11 commitsMon 9:00 — 12 commitsMon 10:00 — 14 commitsMon 11:00 — 13 commitsMon 12:00 — 15 commitsMon 13:00 — 21 commitsMon 14:00 — 23 commitsMon 15:00 — 27 commitsMon 16:00 — 26 commitsMon 17:00 — 27 commitsMon 18:00 — 25 commitsMon 19:00 — 32 commitsMon 20:00 — 17 commitsMon 21:00 — 25 commitsMon 22:00 — 27 commitsMon 23:00 — 19 commitsTue 0:00 — 35 commitsTue 1:00 — 26 commitsTue 2:00 — 13 commitsTue 3:00 — 16 commitsTue 4:00 — 10 commitsTue 5:00 — 6 commitsTue 6:00 — 4 commitsTue 7:00 — 7 commitsTue 8:00 — 7 commitsTue 9:00 — 6 commitsTue 10:00 — 9 commitsTue 11:00 — 17 commitsTue 12:00 — 4 commitsTue 13:00 — 11 commitsTue 14:00 — 4 commitsTue 15:00 — 9 commitsTue 16:00 — 12 commitsTue 17:00 — 16 commitsTue 18:00 — 18 commitsTue 19:00 — 49 commitsTue 20:00 — 25 commitsTue 21:00 — 26 commitsTue 22:00 — 30 commitsTue 23:00 — 33 commitsWed 0:00 — 33 commitsWed 1:00 — 22 commitsWed 2:00 — 7 commitsWed 3:00 — 5 commitsWed 4:00 — 3 commitsWed 5:00 — 5 commitsWed 6:00 — 7 commitsWed 7:00 — 7 commitsWed 8:00 — 2 commitsWed 9:00 — 12 commitsWed 10:00 — 27 commitsWed 11:00 — 7 commitsWed 12:00 — 11 commitsWed 13:00 — 20 commitsWed 14:00 — 12 commitsWed 15:00 — 17 commitsWed 16:00 — 17 commitsWed 17:00 — 21 commitsWed 18:00 — 26 commitsWed 19:00 — 14 commitsWed 20:00 — 26 commitsWed 21:00 — 28 commitsWed 22:00 — 34 commitsWed 23:00 — 35 commitsThu 0:00 — 39 commitsThu 1:00 — 21 commitsThu 2:00 — 23 commitsThu 3:00 — 16 commitsThu 4:00 — 2 commitsThu 5:00 — 1 commitsThu 6:00 — 3 commitsThu 7:00 — 5 commitsThu 8:00 — 8 commitsThu 9:00 — 2 commitsThu 10:00 — 19 commitsThu 11:00 — 21 commitsThu 12:00 — 20 commitsThu 13:00 — 31 commitsThu 14:00 — 21 commitsThu 15:00 — 14 commitsThu 16:00 — 21 commitsThu 17:00 — 20 commitsThu 18:00 — 35 commitsThu 19:00 — 25 commitsThu 20:00 — 19 commitsThu 21:00 — 23 commitsThu 22:00 — 22 commitsThu 23:00 — 18 commitsFri 0:00 — 25 commitsFri 1:00 — 20 commitsFri 2:00 — 16 commitsFri 3:00 — 5 commitsFri 4:00 — 6 commitsFri 5:00 — 8 commitsFri 6:00 — 5 commitsFri 7:00 — 4 commitsFri 8:00 — 6 commitsFri 9:00 — 13 commitsFri 10:00 — 11 commitsFri 11:00 — 7 commitsFri 12:00 — 14 commitsFri 13:00 — 21 commitsFri 14:00 — 28 commitsFri 15:00 — 15 commitsFri 16:00 — 12 commitsFri 17:00 — 18 commitsFri 18:00 — 93 commitsFri 19:00 — 45 commitsFri 20:00 — 58 commitsFri 21:00 — 35 commitsFri 22:00 — 40 commitsFri 23:00 — 46 commitsSat 0:00 — 28 commitsSat 1:00 — 37 commitsSat 2:00 — 29 commitsSat 3:00 — 15 commitsSat 4:00 — 4 commitsSat 5:00 — 35 commitsSat 6:00 — 5 commitsSat 7:00 — 6 commitsSat 8:00 — 14 commitsSat 9:00 — 9 commitsSat 10:00 — 19 commitsSat 11:00 — 25 commitsSat 12:00 — 27 commitsSat 13:00 — 36 commitsSat 14:00 — 39 commitsSat 15:00 — 49 commitsSat 16:00 — 36 commitsSat 17:00 — 31 commitsSat 18:00 — 62 commitsSat 19:00 — 61 commitsSat 20:00 — 61 commitsSat 21:00 — 25 commitsSat 22:00 — 36 commitsSat 23:00 — 48 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits3,599 (65%)
Community commits1,979 (35%)

5,578 commits in total over the last year.

Package Contents
default (codebase-memory-mcp) Standard server, no UI
codebase-memory-mcp-ui Server with CBM Lens embedded (--ui=true works)
graph-ui Just the built CBM Lens assets (dist/)
DateListRankStars gained
Sep 24, 2026daily#12+201
Sep 23, 2026daily#12+201
Jul 30, 2026monthly#15+17,707
Jul 29, 2026monthly#15+17,707
Jul 28, 2026monthly#11+19,689
Jul 27, 2026monthly#6+20,672
Jul 26, 2026daily#18+3
Jul 13, 2026daily#18+3
Jul 8, 2026daily#23+4
Jul 6, 2026daily#19+5
Jul 5, 2026daily#22+18
Jul 4, 2026daily#18+23
Jul 3, 2026daily#13+12
Jul 2, 2026daily#17+23
Jul 1, 2026daily#14+20
  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • affaan-m/ECC

    The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

    307.9K stars · JavaScript

  • NousResearch/hermes-agent

    The agent that grows with you

    265K stars · Python

  • n8n-io/n8n

    Fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations.

    211.6K stars · TypeScript

  • DietrichGebert/ponytail

    Makes your AI agent think like the laziest senior dev in the room. The best code is the code you never wrote.

    195.7K stars · JavaScript

  • farion1231/cc-switch

    A cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode,DeepSeek Harness and more. Only official website: ccswitch.io

    156K stars · Rust