What can you do with this server?

A self-hosted, hybrid code search MCP server for local codebases, enabling AI agents to search and explore code using multiple layers: * search_text — Exact full-text search (FTS5) for known strings, identifiers, config keys, or error messages. * search_symbol — Find definitions of functions, classes, methods, etc. by name (exact or substring match). * file_symbols — Get a full outline of all symbols in a specific file, ordered by line number. * search_semantic — Fuzzy, meaning-based vector similarity search via Qdrant (e.g. "where do we validate refunds"). * search_hybrid — Combined search across all three layers simultaneously — best when unsure which layer fits. * list_services — List all registered microservice indexes (name, ID, path). * reindex — Trigger incremental or full index rebuilds for a service. * index_stats — View indexed file/symbol counts and semantic layer health for a service. Additional capabilities include: filtering results by path using path_glob/exclude_glob, reading specific code spans from indexed files, managing per-project ignore rules (including .gitignore integration), auto-reindexing via a background daemon on filesystem events, monitoring indexing progress via web or CLI dashboards, and graceful degradation if components like Qdrant or tree-sitter are unavailable.

How do I use code-index-mcp?

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., "@code-index-mcp find the definition of 'handleError' function" 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.

code-index-mcp

by Krat12

Overview Schema Related Servers Score Discussions

Python

Local

code-index-mcp

Self-hosted hybrid code search as an MCP server for Kilo CLI / OpenCode. Everything runs locally on your machine — no third-party MCP servers, no LSP, no SaaS.

Three search layers, one server:

Layer	Engine	Good for
text	SQLite FTS5	exact strings, identifiers, config keys, errors
symbols	tree-sitter	"where is `X` defined", file outline
semantic	fastembed (local) → Qdrant	fuzzy "where do we do Y"

Don't want to configure this yourself? Let your agent do it

You don't need to learn the env vars, registry file, or Qdrant. Just tell your coding agent (Kilo CLI / OpenCode) to set it up from the runbook:

"Set up code-index for me, following the instructions at https://github.com/Krat12/mcp-code-index/blob/main/docs/AGENT_SETUP.md"

The agent reads docs/AGENT_SETUP.md, checks your environment, asks you only the few things it can't decide (which repos, your embeddings API key, whether to honor each repo's .gitignore, what else to ignore), wires everything up, builds the index, optionally installs the code-search skill so sub-agents can use the CLI fallback, and tells you where everything lives — without writing anything into your repos. The rest of this README is the manual reference for those who prefer to do it by hand.

Related MCP server: codesteer-atlas

Requirements

Python 3.10+
Qdrant running locally (you already have it) at http://localhost:6333
The rest is pip-installed (tree-sitter grammars + fastembed are local; the embedding model downloads once and then runs offline).

Install

# from the project folder
uv venv
uv pip install -e .
# or: pip install -e .

Nothing is written into your repos

All state lives outside the indexed repositories:

SQLite index → ~/.cache/code-index/<service-id>.sqlite3
Qdrant collection → code_<service-id> (derived from the repo's absolute path)
Project registry → ~/.config/code-index/projects.toml

So you never commit anything, never edit .gitignore, and never add git hooks inside the service repos — no PR noise.

Single project

code-index index            # incremental index of CWD (or --path DIR)
code-index index --full     # full rebuild
code-index stats

Microservices (many repos)

# Register each service explicitly...
code-index add C:\work\billing  --name billing
code-index add C:\work\payments --name payments

# ...or point at a parent folder and auto-discover every git repo inside:
code-index add-workspace C:\work --depth 1

code-index list             # show resolved services
code-index index-all        # (re)index every service (per-service index)
code-index stats-all

The registry file (~/.config/code-index/projects.toml) looks like:

[[service]]
name = "billing"
path = "C:/work/billing"

[[workspace]]
path = "C:/work"
depth = 1

Per-project ignore (no files in the repo)

Each [[service]] (and [[workspace]]) can declare what to skip — all in the external registry, so nothing is written into the service repo:

[[service]]
name = "billing"
path = "C:/work/billing"
ignore = ["**/generated/**", "*.pb.go", "docs/legacy/**"]  # extra ignore globs
use_gitignore = true   # ALSO skip whatever the repo-root .gitignore lists

ignore is a list of glob patterns matched against repo-relative POSIX paths. Supported glob/.gitignore-like syntax: * (no /), ** (any depth), ?, a trailing / (directories only), and a leading/embedded / (anchored to the repo root). These are layered on top of the built-in ignores (build dirs, lock files, minified bundles, etc.).
use_gitignore = true additionally reads the repo's top-level .gitignore (read-only — never written). Negation rules (!pattern) and nested per-directory .gitignore files are intentionally not supported, to keep the matcher tiny and predictable.
For a [[workspace]], ignore/use_gitignore are inherited by every auto-discovered repo under it.

Watch indexing progress

code-index index            # shows a live rich progress bar (TTY)
code-index index --plain    # plain stderr logging instead
code-index status           # one-shot table: phase / progress / files / symbols
code-index status --watch   # live dashboard, refreshes ~1/s (Ctrl+C to stop)
code-index web              # tiny local web dashboard at http://127.0.0.1:8765
code-index web --port 9000  # pick another port

Progress is shared across processes via tiny JSON files in ~/.cache/code-index/status/<id>.json (atomic writes). So you can run code-index status --watch (or open the web page) in one terminal and watch the background code-index-watch daemon — or an index-all running elsewhere — make progress in real time. The web UI is opt-in (started only by code-index web), single-threaded, and does work only when the browser polls — deliberately light for a low-power machine.

Auto re-index (no git hooks)

A background daemon keeps every registered service fresh using filesystem events (watchdog) plus a periodic safety sweep — all outside the repos:

code-index-watch                 # FS events + sweep every 600s
code-index-watch --interval 300  # sweep every 5 min
code-index-watch --no-periodic   # FS events only

Leave it running (e.g. as a startup task / Windows service). It does an initial incremental index of each service, then re-indexes only what changes.

Wire it into Kilo CLI / OpenCode

Add a local MCP server to your config (~/.config/kilo/opencode.json for Kilo CLI, or ~/.config/opencode/opencode.json for OpenCode; a per-project opencode.json works too):

One MCP server can serve all your microservices — the agent picks the service per call (or uses the default CWD service). Put this in the global config (~/.config/kilo/opencode.json for Kilo, ~/.config/opencode/opencode.json for OpenCode):

{
  "$schema": "https://app.kilo.ai/config.json",
  "mcp": {
    "code-index": {
      "type": "local",
      "command": ["code-index-mcp"],
      "enabled": true,
      "environment": {
        "CODE_INDEX_ROOT": "${cwd}",
        "QDRANT_URL": "http://localhost:6333",
        "CODE_INDEX_EMBED_MODEL": "BAAI/bge-small-en-v1.5",
        "CODE_INDEX_SEMANTIC": "1"
      }
    }
  }
}

If code-index-mcp isn't on PATH, use the absolute path to the venv script, e.g. ["C:/Users/you/PycharmProjects/code-index-mcp/.venv/Scripts/code-index-mcp.exe"], or ["python", "-m", "code_index.server"] with the venv's python.

Restart the CLI. The agent now sees tools: search_text, search_symbol, file_symbols, read_span, search_semantic, search_hybrid, list_services, reindex, index_stats. Every search tool takes an optional service (name or id from list_services).

read_span(path, start_line, end_line, context=0, service=...) returns the actual source at a location — the natural follow-up to a search hit, so the agent can read code without a separate file tool (path is confined to the repo; falls back to the index if the file changed/vanished on disk).
search_text/search_symbol/search_semantic/search_hybrid accept path_glob and exclude_glob (globs, comma-separated or a list) to narrow results by repo-relative path, e.g. path_glob="backend/**", exclude_glob="**/tests/**". search_text also degrades gracefully on malformed FTS5 input (it retries the query as a literal phrase).

Keeping the index fresh

Background daemon (recommended): code-index-watch (see above).
On demand from the agent: it can call the reindex tool.
Manual: code-index index / code-index index-all.
At server start: set CODE_INDEX_REINDEX_ON_START=1 for a quick background incremental of the default service when the MCP server launches.

Environment variables

Var	Default	Meaning
`CODE_INDEX_ROOT`	`.`	default project root (single-project / fallback)
`CODE_INDEX_CONFIG_HOME`	`~/.config/code-index`	where `projects.toml` lives
`CODE_INDEX_CACHE_HOME`	`~/.cache/code-index`	where SQLite indexes live
`QDRANT_URL`	`http://localhost:6333`	Qdrant endpoint
`QDRANT_API_KEY`	–	optional Qdrant key
`CODE_INDEX_EMBED_MODEL`	`BAAI/bge-small-en-v1.5`	fastembed model
`CODE_INDEX_SEMANTIC`	`1`	set `0` to disable semantic layer
`CODE_INDEX_REINDEX_ON_START`	`0`	`1` = background reindex on server start

Live indexing status is written to ~/.cache/code-index/status/<id>.json (under CODE_INDEX_CACHE_HOME). Inspect it with code-index status / code-index status --watch, or the code-index web dashboard.

Graceful degradation

No tree-sitter? → symbols layer off, text + semantic still work.
Qdrant down / fastembed missing? → semantic off, text + symbols still work.
The text (FTS5) layer always works as long as the SQLite index exists.

Degradation is visible, not silent:

index_stats reports the semantic layer's health: ok (points=N), disabled (turned off), or unavailable (API/Qdrant unreachable).
search_semantic / search_hybrid distinguish disabled vs unavailable vs "no matches", so the agent knows to fall back to text/symbols instead of treating a down layer as an empty result.
Indexing counts what it couldn't store — chunks that failed to embed and vectors that failed to upsert — and surfaces the totals in the run log, in status.json, and in the status / web dashboards (a ⚠ marker).

Available Tools

8 tools

file_symbolsA

List all symbols (outline) of a single file, ordered by line.

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.6/5.0

Behavior3/5

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

No annotations are provided, so the description must cover behavioral aspects. It states ordering by line but does not detail what symbols are included, file type limitations, or error conditions. Basic but incomplete.

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

Conciseness4/5

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

The description is one concise sentence, but it could be slightly more informative without becoming verbose.

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?

The tool has an output schema, so return values are defined elsewhere. The description is mostly complete for a simple tool, though it lacks context on file type support or prerequisites.

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

Parameters2/5

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

Schema description coverage is 0%, and the description adds no meaning beyond parameter names. It does not explain what 'path' or 'service' represent or their constraints.

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 lists symbols (outline) of a single file, ordered by line, which distinguishes it from sibling search tools that operate across files.

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

Usage Guidelines3/5

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

The description implies use for a single file's outline but does not explicitly state when to use this tool versus alternatives like search_symbol. No exclusions or when-not guidance is provided.

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

index_statsB

Show how many files and symbols are currently indexed for a service.

ParametersJSON Schema

Name	Required	Description	Default
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.1/5.0

Behavior3/5

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

With no annotations, the description correctly implies a read-only operation ('Show'), but does not disclose any edge cases or behaviors (e.g., behavior when service is null). Adequate but not thorough.

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?

A single, front-loaded sentence with no extraneous words. Efficient and to the point.

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 stats tool with one optional parameter and an output schema, the description is minimally sufficient. However, it lacks clarification on the optional parameter and does not leverage the output schema to explain return values.

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

Parameters2/5

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

Schema coverage is 0%, so the description must explain the 'service' parameter. It mentions 'for a service' but neither defines the parameter nor notes its optionality and null default, leading to potential misinterpretation.

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

Purpose4/5

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

The description clearly states the tool shows index statistics (files and symbols) for a service, distinguishing it from search and reindex siblings. However, it does not clarify that the 'service' parameter is optional, which could be confusing.

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

Usage Guidelines2/5

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

No guidance on when to use this tool versus alternatives like 'file_symbols' or 'list_services'. No context on prerequisites or typical use cases.

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

list_servicesA

List indexable microservices from the external registry.

Returns name, id and path for each. Pass a name or id as the service argument of the search tools to target a specific microservice.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior3/5

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

No annotations provided, so description bears full burden. It discloses return fields (name, id, path) but does not mention potential issues like registry unavailability or rate limits. Adequate for a simple read operation.

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 concise sentences, front-loaded with the main action and no redundant words. Every sentence adds value.

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?

For a simple list with no params and an output schema, the description covers purpose, return values, and usage context. Minor gaps on error behavior, but acceptable given low complexity.

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

Parameters4/5

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

No parameters exist, schema coverage is 100%. Baseline score of 4 applies since description does not need to add param info.

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 uses a specific verb 'List' and clear resource 'indexable microservices from the external registry', and distinguishes itself from sibling tools (all searches or reindex) by stating the output can feed into search tools.

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 states the tool is for listing microservices and how to use the results (as service argument in search tools). Lacks explicit when-not-to-use or alternatives, but siblings are distinct enough.

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

reindexA

Rebuild the index from disk for one service. Use after large changes.

full=true forces a complete re-index; otherwise only changed files are updated.

ParametersJSON Schema

Name	Required	Description	Default
`full`	No
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.5/5.0

Behavior3/5

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

No annotations are provided, so the description carries the full burden. It explains the behavior of the 'full' parameter but does not disclose potential side effects (e.g., performance impact, temporary unavailability) or whether the operation is safe to run concurrently.

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

Conciseness4/5

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

The description is two concise sentences, front-loaded with the purpose. Every sentence adds value. Could be slightly more structured, but overall efficient.

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 the presence of an output schema, return values are not required. The description covers the core purpose, parameter behavior, and usage context. Missing details about constraints (e.g., service format) are minor given the tool's straightforward nature.

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 0% so description must compensate. It explains 'full' well: 'full=true forces a complete re-index; otherwise only changed files are updated.' However, 'service' is only vaguely described as 'for one service' without listing possible values or format, leaving interpretability gaps.

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

Purpose4/5

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

The description states 'Rebuild the index from disk for one service,' which clearly identifies the action and resource. It distinguishes from sibling tools like search_* and index_stats by specifying it's about rebuilding, not querying or stats.

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

Usage Guidelines3/5

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

The description includes 'Use after large changes,' which gives a high-level usage context. However, it does not specify when not to use the tool or mention alternatives among siblings, leaving some ambiguity.

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

search_hybridA

Best-effort combined search: symbols + text + semantic for one service.

Prefer this when you're not sure which layer fits. service selects the index (name or id); omit for the default service.

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`limit`	No
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

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 fully disclose behavior. It mentions 'best-effort' but does not clarify implications (e.g., result consistency, rate limits). There is no mention of side effects or whether the tool is read-only, which is insufficient for a search tool with multiple sub-types.

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 extremely concise with two sentences and one note. It front-loads the purpose and provides usage guidance without 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 the tool's complexity (combining three search types) and the presence of an output schema, the description is adequate but not thorough. It lacks discussion of error handling, result ordering, or how the hybrid approach differs from individual search tools.

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?

The description adds meaning to the 'service' parameter ('selects the index (name or id); omit for the default service'), but does not elaborate on 'query' or 'limit' beyond what the schema provides. With 0% schema coverage, the description partially compensates but leaves gaps.

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 'Best-effort combined search: symbols + text + semantic for one service', specifying the tool's function as a multi-layer search. It effectively distinguishes from siblings like search_symbol, search_text, and search_semantic.

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 gives explicit guidance: 'Prefer this when you're not sure which layer fits', indicating the use case. It also explains the service parameter's role. However, it does not explicitly state when not to use it or list alternatives.

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

search_semanticA

Fuzzy meaning-based search (vector similarity via Qdrant).

Use for conceptual queries like "where do we validate refunds" when you don't know exact identifiers. service selects the index.

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`limit`	No
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4/5.0

Behavior3/5

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

No annotations provided, so description carries full burden. Reveals it's vector similarity search, but omits behavioral traits like idempotence, return format, or error conditions. Adequate but incomplete.

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 concise, front-loaded sentences. Every word adds value; no 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?

Output schema exists, so return format may be documented elsewhere. Description covers purpose and one parameter, but misses details on limit behavior and edge cases. Reasonably complete given complexity.

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 0%, so description must compensate. It explains 'service' selects the index, but adds no detail for query or limit. Partial value.

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 'fuzzy meaning-based search (vector similarity via Qdrant)' with an example query, distinguishing it from siblings like search_text and search_symbol.

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?

Explicit advice: 'Use for conceptual queries... when you don't know exact identifiers.' Mentions service parameter selects index. Lacks explicit when-not-to-use or alternative names, but context is clear.

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

search_symbolB

Find symbol definitions (function/class/method/record/...) by name.

Use to jump to where something is DEFINED. Set exact=true for an exact name match, otherwise substring matching is used. service selects the index.

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes
`limit`	No
`exact`	No
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.4/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 fully disclose behavior. It does not mention whether the operation is read-only, requires authentication, or has any side effects. The explanation is limited to parameter effects.

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 (two sentences plus a line of parameter notes), front-loaded with purpose, and contains no redundant information.

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?

Covers purpose, parameters, and basic usage. Missing behavioral context like error cases, return format (though output schema exists), or prerequisites. Adequate but not thorough.

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

Parameters4/5

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

With 0% schema description coverage, the description explains all three non-required parameters (limit, exact, service) and their defaults or meanings, adding value beyond the raw schema.

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

Purpose4/5

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

The description clearly states the tool's purpose ('Find symbol definitions') with a specific verb and resource, and gives examples of symbol types. It implies differentiation from siblings by focusing on definitions rather than text search, but does not explicitly name alternatives.

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

Usage Guidelines3/5

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

Provides basic guidance (use to jump to definitions, explains exact and service parameters) but lacks explicit when-not-to-use or alternative tool suggestions. Siblings like search_text and file_symbols are not addressed.

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

search_textA

Exact full-text search across a service (FTS5). Returns path:line: content.

Use for known strings, identifiers, config keys, error messages. Supports FTS5 syntax, e.g. "foo AND bar", "exact phrase", prefix*. service selects which microservice index to search (name or id); omit for the default service.

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`limit`	No
`service`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.2/5.0

Behavior3/5

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

No annotations are provided, so the description must carry the full burden. It mentions the return format and that it uses FTS5, but lacks details on pagination, rate limits, or side effects. For a read-only search tool, the disclosure is adequate but not comprehensive.

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 with no waste. The first sentence states the core purpose and output. The second gives usage guidance, and the third explains parameter semantics. Information is front-loaded efficiently.

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 the presence of an output schema (not detailed in description) and 3 parameters, the description covers purpose, usage, return format, and parameter meanings. It omits explicit limits on result count or pagination, but the schema hints at 'limit' with default. Overall, sufficiently complete for a search tool.

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

Parameters4/5

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

Schema description coverage is 0%, so the description adds crucial meaning: for 'query', it provides FTS5 syntax examples; for 'service', it explains selection of microservice index. The 'limit' parameter is not elaborated, but the schema provides default. Overall, it compensates well for missing schema descriptions.

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 performs 'Exact full-text search across a service (FTS5)' and specifies the return format 'path:line: content'. This distinguishes it from sibling tools like search_semantic and search_hybrid, which imply non-exact or semantic search.

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?

It explicitly lists use cases: 'Use for known strings, identifiers, config keys, error messages.' It does not mention when not to use, but the context of siblings provides some guidance. The description also explains FTS5 syntax and service selection.

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.

8 tool updatesv0.1.0Jun 23, 2026
- First observedfile_symbols
- First observedindex_stats
- First observedlist_services
- First observedreindex
- First observedsearch_hybrid
- First observedsearch_semantic
- First observedsearch_symbol
- First observedsearch_text

Install Server

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

TDQS

A3.9/5.0

Disambiguation5/5

Each tool has a distinct purpose: file_symbols for file outline, index_stats for statistics, list_services for service listing, reindex for rebuilding, and four differentiated search tools (hybrid, semantic, symbol, text) with clear guidance on when to use each.

Naming Consistency5/5

All tool names follow a consistent snake_case verb_noun pattern (e.g., search_hybrid, file_symbols, list_services), making the set predictable and easy to navigate.

Tool Count5/5

With 8 tools, the surface is well-scoped for a code index server: listing, stats, rebuilding, and four search variants cover the core functionality without bloat.

Completeness4/5

The tool set covers essential operations (list services, rebuild index, search, show file symbols) but lacks granular index management (e.g., individual file add/remove) and cross-service search, limiting flexibility in some workflows.

Maintenance

ActivityStale

ResponsivenessNo issues

Resources

GitHub Repository

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

mcp A
ai.llmse
Public MCP server for the LLM Search Engine
Search RAG Systems Developer Tools
102
DocsMint
io.github.HiAi-gg
Self-hosted AI-native knowledge workspace with hybrid search, GraphRAG, and MCP.
Documentation Access RAG Systems Knowledge & Memory
171
Maguyva
ai.maguyva
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Code Analysis Coding Agents
23
Palim A
io.github.joleschmidt
Hosted MCP memory: save sessions/decisions once, search from Claude, Cursor, ChatGPT. EU-hosted FTS.
Knowledge & Memory Search RAG Systems
92

Related MCP Servers

reporelay
RAG Systems Code Analysis
chwoerz
A
license
Not graded
quality
F
maintenance
Self-hosted MCP server for indexing and searching code repositories via hybrid search and deep code understanding.
Updated 4 months ago (2026-04-24 22:10 UTC)
21
18
MIT
codesteer-atlas
Code Analysis Search RAG Systems
LuisCarlosLopes
A
license
A
quality
A
maintenance
Local MCP server for semantic code search using Tree-sitter AST parsing, local embeddings, and hybrid search; enables indexing and querying codebases entirely offline.
Updated 19 hours ago (2026-09-05 14:26 UTC)
5
MIT
embecode
Code Analysis Developer Tools Search
jdtzmn
A
license
A
quality
D
maintenance
Local-first MCP server for semantic + keyword hybrid code search. Zero external services, no API keys required.
Updated 6 months ago (2026-02-27 19:55 UTC)
2
MIT
mcp-codesearch
Code Analysis Vector Databases Developer Tools
michaelkrauty
A
license
A
quality
A
maintenance
MCP server for semantic code search with AST-aware chunking, hybrid vectors, and query syntax.
Updated 2 days ago (2026-09-04 20:22 UTC)
12
1
Apache 2.0

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/Krat12/mcp-code-index'

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