Codebase Memory Mcp

    1

    Turn local git repositories into a queryable MCP memory graph for faster codebase navigation and symbol lookup.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    codebase-memory-mcp

    Example session with this skill installed

    I need to understand the codebase structure. Can you find the main entry point and tell me who has been working on the core logic lately?

    • Read your context and instructions
    • Compiled the codebase-memory-mcp

    Indexed the repo at server launch and answered in 3 tool calls - no file reading.

    Repo overview

    Team activity (team_activity):

    AuthorCommits
    hari235311

    Most relevant files for "main entry point" (get_codebase_context):

    1. tests/test_repoindex.py (rank 4)
    2. tests/test_graph.py (rank 4)
    3. src/codebase_memory_mcp/repoindex.py (rank 4)
    4. tests/test_detect_changes.py (rank 3)

    Recent commits (same call):

    • wire-level proof: spawn server, call all 4 tools over stdio
    • graph: sqlite nodes/edges + read APIs for the 4 tools
    • repoindex: commits + tree + regex symbol scan (py/ts/md)

    Symbol hits for "e2e"

    search_codebase_memory("e2e") -> 20 symbols incl. test_e2e_tools_over_stdio, main in scripts/e2e_client.py

    Where to look next

    1. src/codebase_memory_mcp/mcp_server.py - FastMCP app wiring the 4 tools (entry point)
    2. src/codebase_memory_mcp/repoindex.py - indexing: git log + file tree + symbol scan
    3. src/codebase_memory_mcp/graph.py - sqlite graph nodes/edges

    Next steps

    1. Read mcp_server.py for the tool surface.
    2. Add the server to your MCP client config with your repo path.
    3. Ask get_codebase_context before grepping - it answers structural questions in one call.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Stop wasting tokens on recursive grepping and manual file exploration. Large repositories overwhelm standard agent context, leading to hallucinations or missed architectural patterns. This skill installs and configures a dedicated MCP server that turns any local git repository into a queryable SQLite graph of symbols, commits, and file relationships.

    What it does

    • Index codebases by mapping files, commits, and symbols into a persistent SQLite graph.
    • Find implementations using ranked context searches to locate where specific features are defined.
    • Locate symbols across Python and TypeScript files using fuzzy name matching for classes and functions.
    • Analyze file history to see who authored specific modules and what recent changes were committed.
    • Track team activity by identifying top contributors and commit frequency across the project.

    How it works

    1. Environment setup by creating a dedicated Python virtual environment and installing the server package.
    2. MCP registration by adding the server configuration to your IDE or agent config with the absolute path to your target repository.
    3. Graph querying using standard tools like get_codebase_context or search_codebase_memory to navigate the repo.
    4. Snapshot refresh by restarting the MCP server after significant code changes to update the index.

    Frameworks & tools

    Built for Python 3.10+ environments. Supports indexing for Python (.py), TypeScript (.ts), and Markdown (.md) files. Integrates with MCP-compliant clients including Claude Code, Cursor, and GitHub Copilot.

    Why this beats prompting it yourself

    Generic agents struggle to see the "big picture" of a repo without reading every file, which is slow and expensive. This skill provides a structured index, allowing the agent to perform surgical lookups and understand repository structure in milliseconds without consuming your context window.

    Use cases

    • Onboarding to a legacy repository by identifying entry points and main contributors.
    • Finding specific class definitions or function implementations in large monorepos.
    • Reviewing recent commit history to understand the context of a bug or feature.
    • Scaffolding new features by finding existing patterns through symbol search.

    Known limitations

    Requires a local git repository. Does not support call graph analysis or "who calls X" queries. Graph is a static snapshot and requires a server restart to reflect new changes.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires local git repo and Python 3.10+. No call graph analysis (cannot track callers). Index is a snapshot and requires server restart to update after changes.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 day ago

    • Free with an Agensi account

    Software
    PythonGitCodebase Memory MCPuv (Python tool runner)Config MCPCbm Venv MCP

    Setup is one command: the agent runs uvx to fetch, build and cache the server from GitHub, then registers it with your MCP client - no venv, no pip, no accounts or API keys. Works the same on macOS, Linux and Windows. The index is a snapshot from server start: restart the MCP server after heavy…

    Permissions

    Terminal / Shell
    Network Access
    Write Files
    Read Files

    Terminal/Shell installs the server (uvx) and runs it locally; Read Files lets the agent index your repo (git history + files); Write Files saves the MCP client config; Network Access downloads the package from GitHub (cached by uvx). Everything runs on your machine - no accounts, keys or uploads.

    Listed3 days ago
    Updated1 day ago

    What's inside

    Frequently Asked Questions

    This skill solves the 'context window' problem by indexing your local git repository into a SQLite graph, allowing AI agents to perform surgical symbol lookups instead of reading every file or using slow recursive greps.

    The skill is compatible with any MCP-compliant client, including Claude Code, Cursor, and GitHub Copilot/Windsurf, provided the agent can access your local file system.

    While it indexes all file paths in a git repo, deep symbol indexing (functions, classes, and definitions) is currently optimized for Python, TypeScript, and Markdown files.

    The graph is a static snapshot of your repository; to reflect new commits or code changes in the agent's memory, you simply need to restart the MCP server to refresh the index.

    Setup involves creating a Python 3.10+ virtual environment and adding the absolute path of your local repository to your MCP client's configuration file.

    No, the skill only supports local git repositories; it requires direct file system access to parse symbols and commit history into the SQLite database.

    New in Agents & Orchestration

    Free