SRC (Structured Repo Context)

Transform your codebase into AI-ready context — MCP server + CLI for semantic code search that makes your code truly understandable for AI assistants

SRC is both:

• 🔌 An MCP Server — Integrates with Claude Desktop, Cursor, and any MCP-compatible AI assistant
• 💻 A Standalone CLI — Use directly from your terminal for indexing and searching

Table of Contents

1. Overview
2. Quick Start
3. Installation
4. MCP Tools Reference
5. CLI Reference
6. Configuration
7. Supported Languages
8. How It Works
9. Comparison
10. Troubleshooting
11. Links

Overview

The Problem

AI assistants struggle to understand your entire codebase:

• They only see small snippets of code at a time
• Manual copy-pasting of context is tedious and error-prone
• Keyword search misses semantic relationships between code
• Code changes get lost in conversation history

The Solution

SRC indexes your codebase into semantic, searchable chunks that LLMs actually understand:

Use Cases

Quick Start

1. Install Ollama

SRC requires Ollama for embeddings:

# Install from https://ollama.com, then:
ollama pull nomic-embed-text

2. Install SRC

Global installation:

npm install -g src-mcp

Or use npx:

npx -y src-mcp serve

3. Use as MCP Server (with AI Assistants)

Add to your MCP client configuration (e.g., Claude Desktop):

With global installation:

{
  "mcpServers": {
    "src-mcp": {
      "command": "src-mcp",
      "args": ["serve"]
    }
  }
}

With npx:

{
  "mcpServers": {
    "src-mcp": {
      "command": "npx",
      "args": ["-y", "src-mcp", "serve"]
    }
  }
}

The server automatically indexes the current directory if no index exists, and watches for file changes.

Then in your AI assistant:

"Search for authentication logic"
"Find error handling code with limit 20"
"Search for UserService in fts mode"

4. Use as CLI (Standalone)

# Start server (auto-indexes if needed)
src-mcp serve

# Search for code
src-mcp search_code --query "authentication"
src-mcp search_code --query "error handling" --limit 20
src-mcp search_code --query "UserService" --mode fts

# Check index status
src-mcp get_index_status

Key Arguments

Installation

Global Installation

npm install -g src-mcp

Then use directly:

src-mcp serve
src-mcp search_code --query "authentication"
src-mcp help

npx (No Installation)

npx -y src-mcp serve
npx -y src-mcp search_code --query "authentication"

Local Development

git clone https://github.com/kvnpetit/structured-repo-context-mcp.git
cd structured-repo-context-mcp
npm install
npm run dev

MCP Tools Reference

SRC exposes 5 MCP tools that AI assistants can call:

index_codebase

Index a directory with semantic chunking, AST enrichment, and embeddings.

Example:

"Index the project at /home/user/myapp with concurrency 8"

Returns:

{
  "filesIndexed": 150,
  "chunksCreated": 892,
  "languages": { "typescript": 500, "javascript": 200, "json": 192 }
}

search_code

Hybrid search with vector similarity, BM25 keyword matching, and RRF fusion.

Search Modes:

Example:

"Search for 'user authentication' with limit 20"

Returns:

{
  "results": [
    {
      "content": "export async function authenticateUser(credentials)...",
      "filePath": "src/auth/login.ts",
      "startLine": 45,
      "endLine": 78,
      "symbolName": "authenticateUser",
      "symbolType": "function",
      "score": 0.92,
      "callers": [{ "name": "handleLogin", "filePath": "src/routes/auth.ts", "line": 23 }],
      "callees": [{ "name": "validatePassword", "filePath": "src/auth/crypto.ts", "line": 12 }]
    }
  ]
}

update_index

Incrementally update the index by detecting changed files via SHA-256 hash comparison.

Example:

"Update the index with dry run to see what changed"

Returns:

{
  "added": ["src/new-file.ts"],
  "modified": ["src/auth/login.ts"],
  "deleted": ["src/old-file.ts"],
  "unchanged": 148
}

get_index_status

Get status of the embedding index for a directory.

Example:

"Get the index status for current directory"

Returns:

{
  "exists": true,
  "indexPath": "/home/user/myapp/.src-index",
  "totalFiles": 150,
  "totalChunks": 892,
  "languages": { "typescript": 500, "javascript": 200 }
}

get_server_info

Get server version, capabilities, and configuration.

Returns:

{
  "name": "src-mcp",
  "version": "1.0.0",
  "capabilities": ["indexing", "search", "incremental-update"]
}

CLI Reference

Every MCP tool is also a CLI command. You can use SRC from your terminal without any AI assistant.

General Usage

src-mcp <command> [options]
src-mcp help                    # Show all commands
src-mcp <command> --help        # Show command options

Or with npx:

npx -y src-mcp <command> [options]

Commands

# Start MCP server (auto-indexes if needed, watches for changes)
src-mcp serve
src-mcp serve --no-watch        # Disable file watcher

# Index a codebase manually
src-mcp index_codebase
src-mcp index_codebase --concurrency 8
src-mcp index_codebase --force   # Re-index even if index exists

# Search indexed code
src-mcp search_code --query "authentication"
src-mcp search_code --query "error handling" --limit 20 --mode hybrid
src-mcp search_code --query "UserService" --mode fts  # Exact keyword search

# Update index incrementally
src-mcp update_index
src-mcp update_index --dryRun   # Preview changes only

# Check index status
src-mcp get_index_status

# Server information
src-mcp get_server_info --format json

Configuration

Environment Variables

All settings can be configured via environment variables:

Example:

OLLAMA_BASE_URL=http://192.168.1.100:11434 src-mcp serve

MCP Client Configuration

Claude Desktop (claude_desktop_config.json):

With global installation:

{
  "mcpServers": {
    "src-mcp": {
      "command": "src-mcp",
      "args": ["serve"]
    }
  }
}

With npx:

{
  "mcpServers": {
    "src-mcp": {
      "command": "npx",
      "args": ["-y", "src-mcp", "serve"]
    }
  }
}

With environment variables:

{
  "mcpServers": {
    "src-mcp": {
      "command": "src-mcp",
      "args": ["serve"],
      "env": {
        "OLLAMA_BASE_URL": "http://192.168.1.100:11434"
      }
    }
  }
}

Index Storage

Indexes are stored in .src-index/ directory within each indexed project:

my-project/
├── src/
├── .src-index/              # Created by SRC
│   ├── lancedb/             # Vector database
│   ├── callgraph.json       # Call graph cache
│   └── .src-index-hashes.json  # File hash cache
└── ...

Add .src-index/ to your .gitignore:

.src-index/

Supported Languages

Full AST Support (18 languages)

These languages have complete support: symbol extraction, semantic chunking at function/class boundaries, call graph analysis, and import resolution.

LangChain Fallback (16 languages)

These languages use intelligent text splitting with language-aware rules:

Generic Support (30+ file types)

All other text files use configurable chunking:

Auto-excluded Files

Binary files and lock files are automatically excluded:

• Binaries: .exe .dll .so .png .jpg .mp3 .zip .wasm
• Lock files: package-lock.json yarn.lock pnpm-lock.yaml
• Build outputs: .pyc .class .o dist/ node_modules/

How It Works

Indexing Pipeline

Source Files → Semantic Chunking → AST Enrichment → Cross-file Context → Embeddings → LanceDB
                    ↓                    ↓                  ↓                 ↓
              Split at symbol      Extract symbols    Resolve imports    nomic-embed-text
              boundaries           and metadata       and aliases        768 dimensions

Steps:

1. Scan — Find all supported files (respects .gitignore)
2. Chunk — Split code at function/class boundaries (1000 chars, 200 overlap)
3. Enrich — Add AST metadata (symbols, imports, exports)
4. Resolve — Resolve cross-file imports and TypeScript path aliases
5. Embed — Generate vectors via Ollama (nomic-embed-text)
6. Store — Save to LanceDB with vector and full-text indices
7. Cache — Store file hashes for incremental updates

Search Pipeline

Query → Embed Query → Vector Search ─┐
                                     ├→ RRF Fusion → Add Call Context → Results
Query → Tokenize ───→ BM25 Search ───┘

Steps:

1. Embed — Convert query to vector using same model
2. Vector Search — Find semantically similar chunks (cosine similarity)
3. BM25 Search — Find keyword matches (term frequency)
4. RRF Fusion — Combine rankings with Reciprocal Rank Fusion (k=60)
5. Call Context — Add caller/callee information from call graph
6. Return — Ranked results with full context

Technical Specifications

Comparison

SRC vs Basic Code Search MCPs

Key Advantages

1. Hybrid Search — Combines semantic understanding with keyword precision
2. Call Graph — Understand code relationships, not just content
3. Cross-file Resolution — Follows imports to provide complete context
4. Incremental Updates — Only re-index what changed
5. Semantic Chunking — Splits at symbol boundaries, not arbitrary lines

Troubleshooting

Ollama Connection Failed

Error: Ollama is not available

Solution:

1. Ensure Ollama is running: ollama serve
2. Check the URL: curl http://localhost:11434/api/tags
3. If using remote Ollama: set OLLAMA_BASE_URL

Model Not Found

Error: model 'nomic-embed-text' not found

Solution:

ollama pull nomic-embed-text

Index Already Exists

Error: Index already exists. Use force=true to re-index.

Solution:

• Use force: true parameter to re-index
• Or use update_index for incremental updates

No Results Found

Possible causes:

1. Query too specific — try broader terms
2. Wrong directory — check directory parameter
3. Files excluded — check .gitignore patterns

Slow Indexing

Solutions:

1. Increase concurrency: --concurrency 8
2. Exclude large directories: --exclude node_modules --exclude dist
3. Use faster storage (SSD)

Links

Project

• GitHub Repository
• npm Package
• Report Issues
• Changelog
• Architecture Guide

External

• MCP Specification
• Ollama
• LanceDB
• Tree-sitter

License

MIT © 2026 kvnpetit

npm install -g src-mcp && src-mcp serve
# or
npx -y src-mcp serve