MCP Repo Context Server

A Model Context Protocol (MCP) server that generates deep, structured context from codebases using AST parsing, call graph analysis, and semantic search — enabling AI agents to understand and navigate repositories with minimal token usage.

Built in Go. Two direct dependencies. 35+ tools.

Why

AI coding assistants waste tokens re-reading files every session. This server analyzes repositories once, stores structured context (functions, types, call graphs, behaviors, side effects), and serves it on demand via MCP — so the AI gets precise answers in ~2-4K tokens instead of ~50K+.

Features

• AST-Based Analysis — Full Go AST parsing: functions, types, interfaces, imports, complexity metrics
• Call Graph — Maps caller/callee relationships across the entire codebase, with Mermaid/DOT visualization
• Semantic Search — Local vector embeddings (384-dim) stored in SQLite for meaning-based code search
• Behavior Extraction — Auto-detects what functions do: DB queries (with SQL), HTTP calls, file I/O, error handling
• Multi-Repo Comparison — Find duplicates, conflicts, and gaps across repositories
• Incremental Updates — Refresh a single file (~1-2K tokens) or git changes (~2-5K tokens) without full re-analysis
• AI-Powered Q&A — Natural language queries routed to the right tool automatically via smart_query
• PR Review — Context-aware pull request analysis using function-level impact analysis
• Organization Support — Group repos, query across entire orgs
• Composable Patterns — Pre-built tool chains for common workflows (search + expand, impact analysis)

Architecture

MCP Client (Claude Code / AI Agent)
    |  JSON-RPC 2.0 over stdio
    v
+---------------------------+
|   MCP Server (35+ tools)  |
+-----------+---------------+
            |
    +-------+-------+-----------+-----------+
    v       v       v           v           v
Analyzer  Storage  Vector Store  AI Module  Comparer
 (AST)   (JSON/FS) (SQLite)    (Claude)   (Multi-Repo)
    |
    +-- Go AST parser
    +-- Call graph builder
    +-- Search index (concepts, side effects, routes)
    +-- Behavior summarizer
    +-- Error handling detector

Storage: Each repo is analyzed into a structured JSON file containing all functions, types, call graphs, search indexes, and behavior data. Vector embeddings are stored in SQLite for semantic search.

Quick Start

Prerequisites

• Go 1.24+
• GitHub token (for private repos)
• Anthropic API key (optional, for AI features)

Build

git clone https://github.com/yashpalsinhc/mcp-repo-context.git
cd mcp-repo-context
go build -o mcp-server ./cmd/mcp-server

Run

./mcp-server \
  -storage ./data/contexts \
  -temp /tmp/mcp-repos \
  -github-token $GITHUB_TOKEN

Docker

docker build -t mcp-repo-context .
docker run -it \
  -v $(pwd)/data:/home/mcp/data \
  -e GITHUB_TOKEN \
  -e ANTHROPIC_API_KEY \
  mcp-repo-context

Integrate with Claude Code

Add to your MCP config (~/.claude/settings.json or project .mcp.json):

{
  "mcpServers": {
    "repo-context": {
      "command": "/path/to/mcp-server",
      "args": ["-storage", "/path/to/data/contexts"],
      "env": {
        "GITHUB_TOKEN": "your-token",
        "ANTHROPIC_API_KEY": "your-key"
      }
    }
  }
}

Tools Reference

Analysis

Search & Query

AI-Powered

Visualization & Comparison

System

Configuration

What Gets Extracted (Go)

For every Go file, the analyzer produces:

• Functions: signature, parameters, returns, line range, visibility, complexity
• Behavior: one-line summary, data reads/writes, external API calls, DB queries with SQL
• Types: structs with fields (including JSON/DB tags), interfaces with methods
• Call Graph: full caller/callee map across the codebase
• Search Index: concepts (auth, validation), side effects (db_query, http_call), routes, error types
• HTTP Handlers: method, path, request/response types

Project Structure

cmd/mcp-server/     Entry point, CLI flags, signal handling
internal/
  analyzer/         Go AST parser, call graph, behavior, search index
  ai/               Anthropic Claude integration, context extraction
  comparison/       Multi-repo duplicate/conflict/gap detection
  compose/          Tool composition patterns and chains
  context/          Core types (RepoContext, FileContext, CallGraph)
  graph/            Mermaid/DOT call graph visualization
  mcp/              MCP protocol handler, 35+ tool implementations
  orchestrator/     Analysis orchestration, smart query routing
  org/              Organization-level multi-repo operations
  prreview/         GitHub PR review automation
  repo/             Git clone, file scanning
  storage/          Filesystem-based JSON storage
  vectors/          Local embeddings, SQLite vector store, semantic search
  skills/           Built-in AI prompts (Go expert, PR review, security)

Dependencies

Minimal by design:

• github.com/go-git/go-git/v5 — Git operations
• github.com/mattn/go-sqlite3 — SQLite (vector store)

License

MIT