The Relace MCP Server provides AI-powered code editing and intelligent codebase search through Relace's API, integrating with MCP-compatible editors like Cursor, Claude Code, Windsurf, VS Code, and Codex CLI.
Core Capabilities:
Fast Code Editing (fast_apply) - Apply code changes at 10,000+ tokens/sec to existing or new files with intelligent context-aware merging and smart truncation placeholders
Agentic Local Search (fast_search) - Explore codebases using natural language queries with an autonomous agent that uses grep, ls, and file viewing tools
Cloud Capabilities (requires RELACE_CLOUD_TOOLS=1):
Cloud Synchronization (cloud_sync) - Upload local codebases to Relace Cloud for semantic indexing with incremental, safe full, and mirror full sync modes
Semantic Search (cloud_search) - Perform AI-powered semantic code search using embeddings and reranking to find conceptually related code without exact keyword matches
Repository Management - List repositories (cloud_list), check sync status (cloud_info), and delete repositories with local state cleanup (cloud_clear)
Key Features:
Automatic project root detection via MCP Roots or Git
Cross-platform support (Linux, macOS, Windows via WSL for full features)
Respects .gitignore during cloud sync
Configurable via environment variables or .env files
Optional file logging to platform-specific directories
Custom encoding support for legacy repositories
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Relace MCP Server search for authentication middleware in 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.
Unofficial — Personal project, not affiliated with Relace.
Built with AI — Developed entirely with AI assistance (Antigravity, Codex, Cursor, Github Copilot, Windsurf).
MCP server providing AI-powered code editing and intelligent codebase exploration tools.
Without | With |
Manual grep, misses related files | Ask naturally, get precise locations |
Edits break imports elsewhere | Traces imports and call chains |
Full rewrites burn tokens | Describe changes, no line numbers |
Line number errors corrupt code | 10,000+ tokens/sec merging |
Fast Apply — Apply code edits at 10,000+ tokens/sec via Relace API
Agentic Search — Agentic codebase exploration with natural language queries
Agentic Retrieval — Hybrid semantic hints + live code exploration, with stale-hint support and explicit cloud maintenance (enable with MCP_SEARCH_RETRIEVAL=1; choose the backend with MCP_RETRIEVAL_BACKEND)
Cloud Search — Semantic code search over cloud-synced repositories
Related MCP server: code-context
Prerequisites: uv, git, ripgrep (recommended)
Using the relace backend (default): get your API key from Relace Dashboard, then add to your MCP client:
~/.cursor/mcp.json
{
"mcpServers": {
"relace": {
"command": "uv",
"args": ["tool", "run", "relace-mcp"],
"env": {
"RELACE_API_KEY": "rlc-your-api-key",
"MCP_BASE_DIR": "/absolute/path/to/your/project"
}
}
}
}claude mcp add relace \
--env RELACE_API_KEY=rlc-your-api-key \
--env MCP_BASE_DIR=/absolute/path/to/your/project \
-- uv tool run relace-mcp~/.codeium/windsurf/mcp_config.json
{
"mcpServers": {
"relace": {
"command": "uv",
"args": ["tool", "run", "relace-mcp"],
"env": {
"RELACE_API_KEY": "rlc-your-api-key",
"MCP_BASE_DIR": "/absolute/path/to/your/project"
}
}
}
}.vscode/mcp.json
{
"mcp": {
"servers": {
"relace": {
"type": "stdio",
"command": "uv",
"args": ["tool", "run", "relace-mcp"],
"env": {
"RELACE_API_KEY": "rlc-your-api-key",
"MCP_BASE_DIR": "${workspaceFolder}"
}
}
}
}
}~/.codex/config.toml
[mcp_servers.relace]
command = "uv"
args = ["tool", "run", "relace-mcp"]
[mcp_servers.relace.env]
RELACE_API_KEY = "rlc-your-api-key"
MCP_BASE_DIR = "/absolute/path/to/your/project"Variable | Required | Description |
| ✅* | API key from Relace Dashboard; required for Relace providers and cloud tools |
| ❌ | Set to |
| ❌ | Semantic retrieval backend: |
| ❌ | Retrieval hint policy: |
| ❌ | Opt-in periodic refresh monitor for local indexes; requires a pinned |
| ❌ | Periodic local index monitor interval in seconds (default: |
| ❌ | Initial delay before the first periodic local index check in seconds (default: |
| ❌ | Turn-status user message policy: |
| ❌ | Enable |
| ❌ | Enable LSP-assisted search: |
| ❌ | Project root override (auto-detected via MCP Roots → Git → workspace storage → CWD) |
| ❌ | File logging: |
| ❌ | Path to |
* Optional if both: (1) APPLY_PROVIDER and SEARCH_PROVIDER are non-Relace providers, and (2) MCP_RETRIEVAL_BACKEND is codanna, chunkhound, or none.
For .env usage, encoding settings, custom LLM providers, and more, see docs/advanced.md.
Always available: fast_apply, agentic_search. agentic_retrieval requires MCP_SEARCH_RETRIEVAL=1. Cloud tools are available only when MCP_RETRIEVAL_BACKEND=relace. index_status is available for relace, codanna, and chunkhound, and hidden when MCP_RETRIEVAL_BACKEND=none.
Use MCP-native discovery surfaces: list_tools() for tools and list_resources() for resources.
For detailed parameters, see docs/tools.md.
LSP tools use external language servers installed on your system.
Language | Language Server | Install Command |
Python | basedpyright | (bundled) |
TypeScript/JS | typescript-language-server |
|
Go | gopls |
|
Rust | rust-analyzer |
|
Real-time terminal UI for monitoring operations.
pip install relace-mcp[tools]
relogsFor detailed usage, see docs/dashboard.md.
Evaluate agentic_search performance using the Loc-Bench code localization dataset.
git clone https://github.com/possible055/relace-mcp.git
cd relace-mcp
uv sync --extra benchmark
# Build dataset from Hugging Face
uv run --extra benchmark python -m benchmark.cli.build_locbench --output artifacts/data/raw/locbench_v1.jsonl
# Run evaluation
uv run --extra benchmark python -m benchmark.cli.run --dataset artifacts/data/raw/locbench_v1.jsonl --limit 20All benchmark artifacts are written under benchmark/.data/.
For grid search, analysis tools, and metrics interpretation, see docs/benchmark.md.
Platform | Status | Notes |
Linux | ✅ Fully supported | Primary development platform |
macOS | ✅ Fully supported | All features available |
Windows | ⚠️ Partial |
|
Error or message | Solution |
| Set |
| Include 1-3 unique anchor lines near the target block |
| Verify the path exists and is inside |
| File exceeds 10MB; split the change into smaller files or edits |
| Set |
| Verify the API key and provider configuration |
| Retry later or reduce request volume |
| Check network access and retry |
| Add more specific anchors or concrete new lines so the merge can produce a diff |
| Ensure placeholder markers are used only as placeholders, not expected literal output |
| Split large deletion-heavy edits or use explicit remove directives |
| Break the change into smaller, more local edits |
git clone https://github.com/possible055/relace-mcp.git
cd relace-mcp
uv sync --extra dev --extra benchmark
uv run pytest
uv run --extra dev --extra benchmark pytest benchmark/tests -qMIT
Search codebase for code locations matching a query.
Use when you know the name or structure you're looking for — function names, class names, modules, or how components connect. For conceptual/behavioral queries without known identifiers, use agentic_retrieval instead.
Returns file paths with line ranges and an explanation of findings. Keys: explanation (str), files (dict[path → {lines, snippet}]), turns_used (int).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to find. Prefer specific identifiers over vague concepts. ✅ 'UserService class' ✅ 'where is JWT validation done' ❌ 'error handling' (too vague — results will be poor) Natural language or exact symbol names both accepted. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true, etc. The description adds that the tool returns file paths with line ranges and explanations, providing useful context beyond the annotations. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise (5 sentences), front-loaded with purpose, then usage guidelines, then return format and keys. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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, the description covers purpose, usage, return format, and is supplemented by annotations. With an output schema present, return details are adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the parameter 'query' already has a detailed description with examples in the schema. The tool description adds minimal additional meaning, so baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search codebase for code locations matching a query.' It uses a specific verb ('search') and resource ('codebase'), and distinguishes from the sibling tool 'agentic_retrieval' by noting that this tool is for queries with known identifiers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (when you know the name or structure) and when not to (conceptual/behavioral queries), naming the alternative tool 'agentic_retrieval'. This provides clear guidance for the AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete cloud repository and local sync state. IRREVERSIBLE.
Removes all indexed data from Relace Cloud. Use cloud_list to find repo IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| confirm | No | Must be True to proceed. | |
| repo_id | No | Optional repo ID to delete directly (use cloud_list to find). If not provided, deletes the repo associated with current directory. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark it as destructive (destructiveHint=true). The description adds detail: 'IRREVERSIBLE' and clarifies it removes both cloud data and local sync state, adding value beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise: two sentences plus a warning. All information is front-loaded with the core action, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists (not shown), return values are handled. The description covers the destructive nature, local state removal, and the confirm parameter. Could mention confirmation step explicitly, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear param descriptions. The description adds no extra meaning to params beyond hinting repo_id can come from cloud_list, but does not elaborate on confirm param or provide additional syntactic details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool deletes a cloud repository and local sync state, with the verb 'delete' and specific resource. It distinguishes from siblings like cloud_list (for listing) and implies this is for removal.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description advises using cloud_list to find repo IDs, providing helpful context. However, it does not explicitly state when to use this tool vs alternatives (e.g., cloud_sync) or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
[ADMIN] List all repositories in your Relace Cloud account.
Use to find repo_id for cloud_clear. Not needed for normal search/sync workflow. Returns repository IDs, names, and indexing status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, destructiveHint, idempotentHint; description adds that it returns specific fields and is admin-only, complementing without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with [ADMIN], no fluff; every sentence provides value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Has output schema for returns; description covers purpose, usage, and relationship to siblings; fully adequate for this simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist and schema coverage is 100%; description adds usage context (output fields) beyond schema, meeting baseline for zero-param case.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it lists all repositories, with an admin prefix and explicit use case for cloud_clear, distinguishing from normal search/sync workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (find repo_id for cloud_clear) and when not needed (normal search/sync), providing clear differentiation from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for code by meaning using AI embeddings. Requires cloud_sync first.
Use for conceptual queries where you don't know the exact file, class, or function name. Prefer agentic_search when you know the exact identifier or symbol name.
Prerequisite: cloud_sync must have been run at least once. Fails if RELACE_API_KEY is not set or no sync state exists.
Returns: {results (list), result_count (int), warnings (list[str]), query (str), branch (str), repo_id (str)}. Check warnings[] for stale index alerts (e.g., uncommitted local changes).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Natural language description of the code to find. ✅ 'function that validates JWT and returns user ID' ✅ 'rate limiting middleware for HTTP requests' ❌ 'auth' (too vague — low-relevance results) Be specific about behavior, not just topic. | |
| branch | No | Branch to search (null = API default branch). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already define read-only, idempotent, non-destructive behavior. Description adds failure modes (RELACE_API_KEY, sync state) and return structure with warnings for stale indices.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
8 sentences, all value-adding: purpose, prerequisite, usage guidance, failure conditions, return type, warning tip. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 2 params, annotations, and output schema, the description covers purpose, prerequisites, usage, failures, return shape, and warnings. Complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with detailed descriptions for both parameters. The tool description does not add extra parameter information, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches for code by meaning using AI embeddings, distinguishing it from agentic_search for exact identifier searches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use (conceptual queries) and when to prefer agentic_search (exact identifiers). Also mentions prerequisite cloud_sync and failure conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload or refresh codebase to Relace Cloud for semantic search.
Check index_status() first—skip this if cloud freshness is already 'fresh'. Syncs git-tracked files to enable cloud_search. Incremental by default.
Advanced (Relace-specific): force=True Re-upload all files; use after large refactors. force=True+mirror=True Delete cloud files absent locally; use after branch switch.
Returns: {sync_mode (str), files_created (int), files_updated (int), files_deleted (int), files_unchanged (int), warnings (list[str]), repo_id (str), repo_head (str)}. Check warnings[] for truncation or suppressed deletes. Fails if not in a git repo or RELACE_API_KEY is not set.
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | Ignore cache, upload all files (default: false). | |
| mirror | No | With force=True, delete cloud files not in local (default: false). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Clearly discloses incremental default, idempotent nature (aligning with annotations), and potential destructive behavior of force+mirror, plus warnings about truncation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Structured in concise paragraphs with clear headings for advanced options, return format, and failure conditions—every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Thoroughly covers prerequisites, usage guidance, advanced options, return structure, and failure cases, leaving no gaps given the tool's complexity and existing annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds significant value beyond schema descriptions by explaining advanced use cases for force and mirror, including when to use each option.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with a specific verb+resource ('Upload or refresh codebase to Relace Cloud for semantic search') and distinguishes from siblings by referencing index_status and cloud_search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (after checking index_status), when to skip (if fresh), and provides advanced scenarios for force and mirror usage with concrete examples.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Edit or create a file using intelligent merging.
For new files: writes content directly. For existing files: merges edit_snippet with current content using anchor lines. Anchor lines are verbatim lines copied from the existing file that help locate the exact edit target. Include 1-2 unique lines adjacent to the change. Truncation markers are recommended for larger scoped edits but not required. Markdown files keep fenced code blocks verbatim; outer fence stripping is skipped for .md/.mdx targets.
On error, the response includes a code field:
NEEDS_MORE_CONTEXT: merge model could not locate the target - add 1-2 unique anchor lines from immediately around the edit location.
APPLY_NOOP: merge returned an identical file even though the snippet contained explicit remove directives or concrete new lines not present in the original.
BLAST_RADIUS_EXCEEDED: edit scope too large - split into smaller edits.
MARKER_LEAKAGE: placeholder marker text leaked into merged output (treated as literal text).
TRUNCATION_DETECTED: merged output shrank drastically and no explicit remove directive was provided.
On success: {status: "ok", diff: str | None (unified diff, None for new files or no-op)}.
Do NOT use this tool to delete files or clear file contents. Use a dedicated file management tool for those operations.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | File path (absolute or relative to MCP_BASE_DIR; if MCP_BASE_DIR is unset, relative paths resolve against MCP Roots). | |
| edit_snippet | Yes | Code snippet representing the changes. Include only the lines being added or modified, plus placeholder comments for unchanged parts when useful for larger scoped edits: `// ... existing code ...` (JS/TS), `# ... existing code ...` (Python/shell). Anchor the edit with 1-2 verbatim lines from the existing file. | |
| instruction | No | Optional natural language hint to disambiguate the target location (e.g., 'add after imports', 'inside the if block'). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true and readOnlyHint=false, consistent with a mutating edit. The description adds far more: explains the merging behavior with anchor lines, truncation markers, markdown handling, and a full set of error codes with their meanings and remedies. It also documents the success response format. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is longer than minimal but well-structured: core purpose first, then merge details, then error codes, then a do-not-use note. Each sentence adds value. A slight trim could be made (e.g., the truncation markers sentence could be part of anchor lines), but overall it's efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that an output schema exists (indicated by CONTEXT SIGNALS) and the input schema is fully described, this description is complete: it covers all behavioral aspects, error handling with codes, response format, and explicit exclusions. No gaps remain for an agent to misunderstand.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage for all three parameters. The description still adds substantial value: for 'path' it clarifies resolution relative to MCP_BASE_DIR or MCP Roots; for 'edit_snippet' it gives concrete examples of placeholder comments and anchor line usage; for 'instruction' it provides natural language examples. This goes well beyond the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Edit or create a file using intelligent merging,' which is a specific verb+resource pair. The sibling tools are all cloud/agentic search or index utilities, so this tool is clearly distinct as a file editing tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool: for new files write directly, for existing files merge with anchors. It also provides a clear do-not-use instruction: 'Do NOT use this tool to delete files or clear file contents. Use a dedicated file management tool for those operations' – directly indicating when to avoid it and naming an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Inspect the single active indexing backend in read-only mode.
Use this before retrieval when you need to know whether the active backend is fresh and
whether semantic hints are usable. Returns active_backend, a single backend status
object with freshness and hints_usable, and background_monitor (state, reason).
This tool never refreshes indexes; if active_backend is relace and
backend.status.needs_sync is true, run cloud_sync().
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| trace_id | Yes | Trace ID for correlating logs for this tool call. |
| active_backend | Yes | The configured active indexing backend. |
| base_dir | No | Resolved repository base directory, if available. |
| base_dir_source | No | How the base directory was resolved, when resolution succeeded. |
| backend | No | Status summary for the active backend, when inspection succeeded. |
| background_monitor | No | Background monitor state summary, when inspection succeeded. |
| error | No | Error message explaining why status inspection failed. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds key behavioral details: 'never refreshes indexes', conditions for needing cloud_sync, and outlines the return structure, which goes beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the primary purpose, and every sentence provides essential information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and an output schema, the description sufficiently explains the return fields (active_backend, background_monitor) and the condition for using a sibling tool. It is complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters (0 params, 100% coverage). The description adds no parameter info, which is appropriate as there are none. Baseline 4 is justified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies the verb 'inspect', the resource 'single active indexing backend', and the mode 'read-only'. It clearly defines what the tool does and distinguishes it from siblings like 'cloud_sync'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool ('before retrieval when you need to know whether the active backend is fresh and whether semantic hints are usable') and when not to ('never refreshes indexes') with an alternative ('run cloud_sync()').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.4agentic_searchcloud_clearcloud_listcloud_searchcloud_syncfast_apply4 fields changedInput schema / additionalPropertiesAdded value: +falseInput schema / properties / edit_snippet / descriptionAdded value: +"Code snippet representing the changes. Include only the lines being added or modified, plus placeholder comments for unchanged parts when useful for larger scoped edits: `// ... existing code ...` (JS/TS), `# ... existing code ...` (Python/shell). Anchor the edit with 1-2 verbatim lines from the existing file."Input schema / properties / instruction / descriptionAdded value: +"Optional natural language hint to disambiguate the target location (e.g., 'add after imports', 'inside the if block')."Input schema / properties / path / descriptionAdded value: +"File path (absolute or relative to MCP_BASE_DIR; if MCP_BASE_DIR is unset, relative paths resolve against MCP Roots)."fast_searchindex_statusv1.0.0cloud_clearcloud_infocloud_listcloud_searchcloud_synccloud_clearcloud_infocloud_listcloud_searchcloud_syncfast_applyfast_searchEach tool has a clearly distinct purpose with descriptions that explicitly differentiate similar tools (e.g., agentic_search vs cloud_search based on query type). There is no functional overlap.
Cloud operations use a consistent 'cloud_' prefix, but 'agentic_search', 'fast_apply', and 'index_status' break the pattern. Mix of verb_noun and adjective_noun styles reduces predictability.
Seven tools is well-scoped for a code search and editing server. Each tool addresses a specific need without redundancy or excessive complexity.
Covers search (local and cloud) and file editing, but lacks tools for reading full file content, deleting files, or managing local files beyond edits. Users may need to rely on external tools for basic operations.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
SaaS intelligence for AI agents. 5 unified tools cover 1,000+ services with 91-96% token savings.
Discover, compare, and monitor 1,400+ APIs directly from your AI coding agent.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/possible055/relace-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
