Which integrations are available for this server?

Utilizes Ollama to generate semantic embeddings for codebase indexing and search functionality.

How do I use SRC (Structured Repo Context)?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@SRC (Structured Repo Context) explain how the authentication flow works across the codebase" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

SRC (Structured Repo Context)

by kvnpetit

Overview Schema Source Related Servers Score Discussions Admin

TypeScript

Hybrid

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

codecov npm version npm downloads License: MIT MCP TypeScript Ollama

Related MCP server: code-context-mcp

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:

Feature	Description
Hybrid Search	Vector + BM25 + RRF fusion for optimal results
Call Graph	Shows who calls what and what calls who
Cross-file Context	Resolves imports and path aliases automatically
Incremental Updates	SHA-256 hash detection for fast updates
50+ Languages	18 with full AST support via Tree-sitter

Use Cases

Scenario	Example Query
Code Review	"Show me all error handling in the payment module"
Debugging	"Find where user sessions are created"
Documentation	"Explain the authentication flow"
Refactoring	"List all deprecated API usages"
Onboarding	"How does the routing system work?"
Security Audit	"Find all database query locations"

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

Tool	Argument	Default	Description
`search_code`	`--limit`	10	Max results
`search_code`	`--mode`	hybrid	`hybrid` / `vector` / `fts`
`index_codebase`	`--concurrency`	4	Parallel workers
`index_codebase`	`--force`	false	Re-index if exists

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.

Parameter	Type	Required	Default	Description
`directory`	string	No	`.`	Path to directory to index
`force`	boolean	No	`false`	Force re-indexing if index exists
`exclude`	string[]	No	`[]`	Additional glob patterns to exclude
`concurrency`	number	No	`4`	Parallel file processing workers

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.

Parameter	Type	Required	Default	Description
`query`	string	Yes	—	Natural language search query
`directory`	string	No	`.`	Path to indexed directory
`limit`	number	No	`10`	Maximum results to return
`threshold`	number	No	—	Distance threshold (0-2, vector mode only)
`mode`	enum	No	`hybrid`	Search mode: `hybrid`, `vector`, or `fts`
`includeCallContext`	boolean	No	`true`	Include caller/callee information

Search Modes:

Mode	Description	Best For
`hybrid`	Vector + BM25 + RRF fusion	General queries (default)
`vector`	Semantic similarity only	Conceptual searches
`fts`	Full-text keyword only	Exact identifiers

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.

Parameter	Type	Required	Default	Description
`directory`	string	No	`.`	Path to indexed directory
`dryRun`	boolean	No	`false`	Preview changes without updating
`force`	boolean	No	`false`	Force re-index all files

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.

Parameter	Type	Required	Default	Description
`directory`	string	No	`.`	Path to 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.

Parameter	Type	Required	Default	Description
`format`	enum	No	`text`	Output format: `text` or `json`

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:

Variable	Description	Default
`OLLAMA_BASE_URL`	Ollama API endpoint	`http://localhost:11434`
`EMBEDDING_MODEL`	Model for embeddings	`nomic-embed-text`
`EMBEDDING_DIMENSIONS`	Vector dimensions	`768`
`CHUNK_SIZE`	Characters per chunk	`1000`
`CHUNK_OVERLAP`	Overlap between chunks	`200`
`EMBEDDING_BATCH_SIZE`	Batch size for embedding	`10`
`LOG_LEVEL`	Log verbosity	`info`

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.

Category	Language	Extensions
Web	JavaScript	`.js` `.jsx` `.mjs` `.cjs`
	TypeScript	`.ts`
	TSX	`.tsx`
	HTML	`.html` `.htm`
	Svelte	`.svelte`
Systems	C	`.c` `.h`
	C++	`.cpp` `.hpp` `.cc` `.cxx`
	Rust	`.rs`
	Go	`.go`
Enterprise	Java	`.java`
	C#	`.cs`
	Kotlin	`.kt` `.kts`
	Scala	`.scala` `.sc`
Scripting	Python	`.py` `.pyi` `.pyw`
	Ruby	`.rb` `.rake` `.gemspec`
	PHP	`.php` `.phtml`
Functional	OCaml	`.ml` `.mli`
	Swift	`.swift`

LangChain Fallback (16 languages)

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

Language	Extensions
Markdown	`.md` `.mdx`
LaTeX	`.tex` `.latex`
reStructuredText	`.rst`
Solidity	`.sol`
Protocol Buffers	`.proto`
Lua	`.lua`
Haskell	`.hs` `.lhs`
Elixir	`.ex` `.exs`
PowerShell	`.ps1` `.psm1`
Perl	`.pl` `.pm`
Cobol	`.cob` `.cbl`
Visual Basic	`.vb` `.vbs`
FORTRAN	`.f` `.f90` `.f95`
Assembly	`.asm` `.s`

Generic Support (30+ file types)

All other text files use configurable chunking:

Category	Extensions
Config	`.json` `.yaml` `.yml` `.toml` `.ini` `.env` `.xml`
Shell	`.sh` `.bash` `.zsh` `.fish` `.bat` `.cmd`
Styles	`.css` `.scss` `.sass` `.less`
Data	`.sql` `.graphql` `.gql`
DevOps	`Dockerfile` `Makefile` `.tf` `.hcl`
Other	`.zig` `.nim` `.dart` `.vue` `.elm` `.clj`

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:

Scan — Find all supported files (respects .gitignore)
Chunk — Split code at function/class boundaries (1000 chars, 200 overlap)
Enrich — Add AST metadata (symbols, imports, exports)
Resolve — Resolve cross-file imports and TypeScript path aliases
Embed — Generate vectors via Ollama (nomic-embed-text)
Store — Save to LanceDB with vector and full-text indices
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:

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

Technical Specifications

Component	Specification
Embedding Model	nomic-embed-text (137M params)
Vector Dimensions	768
Chunk Size	1000 characters
Chunk Overlap	200 characters
Batch Size	10 embeddings per request
RRF Constant	k=60
Vector Database	LanceDB (embedded)

Comparison

SRC vs Basic Code Search MCPs

Feature	SRC	Basic MCPs
Search Method	Hybrid (Vector + BM25 + RRF)	Keyword only or basic embedding
Call Graph	Full caller/callee context	None
Cross-file Context	Resolves imports & path aliases	None
Incremental Updates	SHA-256 hash detection	Full re-index required
AST Languages	18 with Tree-sitter WASM	Few or none
Total Languages	50+	Limited

Key Advantages

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

Troubleshooting

Ollama Connection Failed

Error: Ollama is not available

Solution:

Ensure Ollama is running: ollama serve
Check the URL: curl http://localhost:11434/api/tags
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:

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

Slow Indexing

Solutions:

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

License

Ready to supercharge your AI coding experience?

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

Report Bug · Request Feature

Available Tools

5 tools

get_index_statusA

Check if a codebase is indexed and ready for search. USE THIS to verify index exists before searching. Returns file count, chunk count, and indexed languages.

ParametersJSON Schema

Name	Required	Description	Default
`directory`	No	Path to the directory to check (defaults to current directory)	.

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description must disclose behavior. It lists return values (file count, chunk count, indexed languages) but omits details on permissions, error handling, or performance implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences: first states purpose, second adds usage guidance and return values. No wasted words, information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, usage, and return values. No output schema, but description compensates. Lacks details on error cases, but sufficient for a simple verification tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single parameter 'directory'. The tool description adds no additional meaning beyond the schema's existing description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool checks if a codebase is indexed and ready for search. It names the specific resource and provides context relative to sibling tools like index_codebase and search_code.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly tells when to use: 'USE THIS to verify index exists before searching.' Provides clear context for usage, though does not list alternatives or when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_server_infoA

Get SRC server version and capabilities. Use to verify the MCP server is running correctly.

ParametersJSON Schema

Name	Required	Description	Default
`format`	No	Output format	text

TDQS

A3.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only states what the tool gets (version and capabilities) but does not mention whether the operation is read-only, what happens on server error, response size, or any side effects. Minimal disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no unnecessary words, front-loaded with the main purpose. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with one parameter and no output schema, the description explains purpose and usage context. However, it does not mention that the 'format' parameter controls output format (json/text) or describe what capabilities are returned. Slightly incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single parameter 'format', which includes default and enum. The description adds no additional meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get SRC server version and capabilities' and provides a specific use case: 'verify the MCP server is running correctly'. This is a specific verb+resource with an actionable context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'Use to verify the MCP server is running correctly', providing clear context for when to use this tool. However, it does not mention when not to use it or list alternatives, though no obvious siblings overlap in purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

index_codebaseA

Index a codebase for semantic code search. USE THIS FIRST before search_code. Required once per project - creates vector embeddings for 50+ languages. After initial indexing, use update_index for incremental updates.

ParametersJSON Schema

Name	Required	Description	Default
`directory`	No	Path to the directory to index (defaults to current directory)	.
`force`	No	Force re-indexing even if index exists
`exclude`	No	Additional glob patterns to exclude
`concurrency`	No	Number of files to process in parallel (default: 4)

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations, so the description fully covers behavior: it creates vector embeddings for 50+ languages and mentions the initial indexing vs incremental nature, though it could clarify re-indexing implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, each carrying essential information: purpose, usage priority, and alternative tool suggestion. No redundancy, front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, usage, and high-level behavior (vector embeddings). Lacks details on return value or error handling, but sufficient for an indexing action given no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so description adds minimal value to parameter understanding. The description does not elaborate on individual parameters beyond schema defaults.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool indexes a codebase for semantic code search, specifying it is a prerequisite for search_code and distinguishing it from sibling tools like search_code and update_index.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use ('USE THIS FIRST before search_code'), that it is required once per project, and directs to use update_index for incremental updates, providing clear alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_codeA

Search code semantically using natural language queries. USE THIS to find code by concept/meaning (e.g., 'authentication logic', 'error handling'). Requires index_codebase first. Returns relevant code chunks with file locations, function names, and call relationships (who calls what).

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes	Natural language search query
`directory`	No	Path to the indexed directory (defaults to current directory)	.
`limit`	No	Maximum number of results to return
`threshold`	No	Maximum distance threshold for results (lower = more similar)
`mode`	No	Search mode: 'vector' (semantic only), 'fts' (keyword only), 'hybrid' (combined with RRF fusion)	hybrid
`includeCallContext`	No	Include caller/callee information for each result (uses cached call graph)

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It accurately describes the tool as a semantic search that returns code chunks with locations, function names, and call relationships. It also mentions the use of a cached call graph, which is a behavioral detail beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise: three sentences that front-load the core purpose and usage. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description adequately explains the return value (code chunks, locations, functions, call relationships) and prerequisite. It lacks information about error handling or performance, but these are not critical for a search tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description does not add additional parameter-level details beyond what the schema already provides, but it does mention the output structure which indirectly relates to parameters like includeCallContext.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it searches code semantically using natural language queries, distinguishing it from sibling tools like index_codebase and get_index_status. It provides specific examples ('authentication logic', 'error handling') and mentions the key functionality: finding code by concept/meaning.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'USE THIS to find code by concept/meaning' and notes the prerequisite 'Requires index_codebase first'. While it does not list alternatives or when-not-to-use, the usage context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_indexA

Refresh the search index after code changes. USE THIS instead of re-indexing - it's fast because it only processes changed files (SHA-256 hash detection). Use dryRun=true to preview changes first.

ParametersJSON Schema

Name	Required	Description	Default
`directory`	No	Path to the indexed directory	.
`dryRun`	No	Only report changes without updating the index
`force`	No	Force re-index of all files (ignore hash cache)

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully carries the behavioral disclosure burden. It reveals incremental processing via SHA-256 hash detection, speed advantage, and the ability to preview with dry run. However, it doesn't explicitly state if the operation is reversible or if the index must first exist.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, all essential information packed without redundancy. Front-loaded with purpose, then comparative guidance, then best practice. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters, no output schema, and no annotations, the description covers purpose and usage well but lacks any indication of what the tool returns (e.g., success message, list of updated files). Requires the user to infer return behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description adds a usage hint for dryRun but does not elaborate beyond the schema definitions for directory and force. This is adequate but not exceptional.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool refreshes the search index after code changes, using a verb 'Refresh' and a specific resource 'search index'. It distinguishes itself from siblings by explicitly recommending use over re-indexing, likely referencing 'index_codebase'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'USE THIS instead of re-indexing' for updates after code changes and advises using dryRun=true to preview changes first. This provides clear when-to-use and when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

5 tool updatesv1.0.3Mar 11, 2026
- First observedget_index_status
- First observedget_server_info
- First observedindex_codebase
- First observedsearch_code
- First observedupdate_index

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.2/5.0

Disambiguation5/5

Each tool has a distinct purpose: server info, index status, initial indexing, incremental update, and search. No overlapping functionality.

Naming Consistency5/5

All tool names follow a consistent verb_noun snake_case pattern (get_index_status, get_server_info, index_codebase, search_code, update_index).

Tool Count5/5

5 tools is well-scoped for the domain of codebase indexing and semantic search, covering essential operations without redundancy.

Completeness4/5

Covers full lifecycle: server check, index status, initial index, incremental update, and search. Only minor gap is lack of index reset/deletion, which is not essential.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Cortex C
io.cortex.mcp
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Developer Tools Monitoring Observability
312
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
gread A
io.github.NitroRCr
An MCP server that gives your AI access to the source code and docs of all public github repos
Version Control Code Analysis Documentation Access
5361
Symvanta A
com.symvanta
Hosted code graph over MCP: exact callers, dependencies, and cross-repo blast radius for AI agents.
Code Analysis Developer Tools
251

Related MCP Servers

Axon.MCP.Server
Code Analysis Developer Tools Search
ali-kamali
F
license
Not graded
quality
D
maintenance
An MCP server that transforms codebases into intelligent, queryable knowledge bases, enabling AI assistants to perform semantic search, explore architecture, and analyze code relationships.
Updated 2 months ago (2026-06-30 01:32 UTC)
166
-
code-context-mcp
Code Analysis Search Knowledge & Memory
RafaelC457ro
A
license
Not graded
quality
C
maintenance
MCP server for semantic code search and dependency graph analysis. Indexes codebases into a knowledge graph with vector embeddings for AI-powered code understanding.
Updated a month ago (2026-07-30 16:15 UTC)
38
MIT
reposynapse
Code Analysis Developer Tools
Jul879n
A
license
A
quality
D
maintenance
Universal MCP server that analyzes any codebase and provides structured context to AI assistants. Dynamic, accurate, and token-efficient.
Updated 3 months ago (2026-05-27 15:34 UTC)
18
14
MIT
codeweave
Code Analysis Developer Tools
MdAbdullahAlMahmud
A
license
Not graded
quality
D
maintenance
A self-hosted MCP server that indexes your codebase and provides AI assistants with deep context including file tree, full-text search, git history, dependencies, and stack detection, all without sending your code to third parties.
Updated 5 months ago (2026-03-31 19:31 UTC)
15
1
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/kvnpetit/structured-repo-context-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

SRC (Structured Repo Context)

Table of Contents

Overview

The Problem

The Solution

Use Cases

Quick Start

1. Install Ollama

2. Install SRC

3. Use as MCP Server (with AI Assistants)

4. Use as CLI (Standalone)

Key Arguments

Installation

Global Installation

npx (No Installation)

Local Development

MCP Tools Reference

index_codebase

search_code

update_index

get_index_status

get_server_info

CLI Reference

General Usage

Commands

Configuration

Environment Variables

MCP Client Configuration

Index Storage

Supported Languages

Full AST Support (18 languages)

LangChain Fallback (16 languages)

Generic Support (30+ file types)

Auto-excluded Files

How It Works

Indexing Pipeline

Search Pipeline

Technical Specifications

Comparison

SRC vs Basic Code Search MCPs

Key Advantages

Troubleshooting

Ollama Connection Failed

Model Not Found

Index Already Exists

No Results Found

Slow Indexing

Links

Project

External

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API