VecGrep

by VecGrep

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Most tools have clear, distinct purposes: indexing vs searching, vector vs graph vs hybrid. The main ambiguity is between search_code and hybrid_search, since hybrid_search with alpha=1.0 is effectively the same as vector semantic search.
Naming Consistency3/5
Several tools follow a verb_noun pattern (index_graph, index_codebase, search_graph, search_code), but graph_neighbors and hybrid_search deviate by using noun/adjective phrases, and stop_watching uses a gerund instead of a plain verb. The mixed style is readable but not fully consistent.
Tool Count5/5
8 tools is well-scoped for a code search and indexing server. Each tool covers a distinct capability without unnecessary duplication or bloat.
Completeness4/5
Core lifecycle coverage is solid: indexing, searching, graph traversal, hybrid search, status, and watching. Minor gaps exist, such as no explicit delete/remove index tool and no graph-specific status endpoint, but agents can work around these using force reindexing.
Average 4.2/5 across 8 of 8 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- Last stable release on June 9, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It names the action but does not disclose side effects, idempotency, error behavior if no watch is active, or whether any associated state is removed.
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 a single sentence with no filler. The core verb and object are front-loaded, and every word contributes to the meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a state-changing tool with no annotations, the description omits important operational context: when to call it, what path should reference, what happens if nothing is being watched, and what the expected effect is. The one-parameter schema is simple, but the description still does not make the tool confidently callable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not explain the 'path' parameter at all. The agent is left to infer that 'a codebase' refers to the path, but the description adds no meaning beyond the schema's bare 'Path' label.
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?
States a specific verb and resource: 'Stop watching a codebase for file changes.' This is unambiguous and effectively distinguishes the tool from the indexing/search siblings by operation type, though it does not explicitly compare itself to any sibling.
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 is given about when to use this tool versus alternatives, such as when an active watch exists or whether this should be called before re-indexing. The intended use is implied by the operation name, but not explained.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it provides substantial behavioral detail: the scoring formula, normalization of both scores, the alpha blending semantics, and the dependency on prior indexing. It does not mention side effects, error conditions, or read-only guarantees, but for a search tool the disclosed mechanics are strong.
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 well-structured: a one-line summary, a compact formula, a prerequisites line, an Args section, and a Returns section. Every sentence contributes, with no filler or redundant restatement of the tool name.
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 tool's moderate complexity, five parameters, and an output schema, the description provides complete invocation guidance: prerequisites, parameter semantics, and return type. It could add explicit behavior when indexes are missing or stale, but nothing essential is missing for a competent agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully compensate, and it does: every parameter gets meaningful semantics, ranges, defaults, and behavioral effect. This is rare and genuinely helpful for an agent selecting and filling arguments.
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 opens with a specific verb-resource phrase, 'Semantic vector search re-ranked by knowledge graph proximity,' which clearly identifies what the tool does. It further distinguishes itself by detailing the hybrid combination of vector similarity and graph proximity, though it does not explicitly name sibling tools like search_code or search_graph.
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 clearly implies when to use the tool: when a hybrid of vector search and graph proximity is desired, and it states the precondition that both index_codebase and index_graph must have been run. However, it does not explicitly contrast this with pure alternative tools or say 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does so well: it reveals directory walking, AST-based chunking, local embedding, vector storage, incremental updates, background watching, and provider-specific requirements. It is not exhaustive about index location or destructive replacement, but it clearly discloses the main behaviors and side effects.
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 purpose is front-loaded and the Args/Returns sections are structured and scannable. The description is moderately long but each sentence contributes relevant behavioral or parameter information; only minor redundancy exists between the opening summary and later details.
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?
All parameters are explained, the return summary is identified, and important constraints such as incremental updates, provider switching, and watch limitations are covered. It could further clarify prerequisites or the relationship to sibling tools, but the output schema reduces the need to document return values in detail.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the Args section fully compensates for all four parameters. It adds path format (absolute), force semantics (re-index unchanged files), watch behavior and cloud-provider incompatibility, and provider enum values plus environment-variable and dependency requirements.
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 opening sentence clearly states the action ('Index'), the resource ('a codebase directory'), and the purpose ('for semantic search'). The description goes on to describe the core workflow, distinguishing it from sibling search and status tools by focusing on ingestion and vector index construction.
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 provides clear context for when indexing is relevant and explains incremental behavior and provider constraints. However, it never explicitly tells an agent when to choose this tool over siblings like index_graph, search_code, or get_index_status; the guidance is parameter-level rather than tool-selection guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden; it does so by specifying the exact outputs (file count, chunk count, last indexed time, disk usage). The verb 'Get' and 'status' imply a non-mutating read, which is credible. However, it does not explicitly state side-effect-freeness or error behavior (e.g., if path is not indexed), so it reaches but does not exceed a strong baseline.
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 compact and front-loaded: a one-sentence purpose followed by clearly labeled Args and Returns blocks. No filler or redundant repetition of the schema exists.
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 single-parameter read-only status tool with an output schema, the description covers the essential call information: what the tool does, how to specify the path, and which statistics are returned. It omits deeper details such as failure modes and when to prefer this over siblings, which are minor for this simple tool but prevent a perfect completeness score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, path, is fully explained as 'Absolute path to the codebase root directory', adding crucial meaning that the schema itself lacks (the schema only names it 'path' with no description). This is exactly the compensation needed given 0% schema description coverage.
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 states a specific verb ('Get') and resource ('the status of the vector index for a codebase'), making its read-only purpose obvious. This clearly distinguishes it from sibling tools like index_codebase, search_code, and hybrid_search, which perform writing or searching operations.
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 the tool is for inspecting index state, but it provides no explicit guidance on when to choose it over alternatives, nor any exclusion criteria. For example, it does not say 'check this before indexing' or 'use this to determine if search is stale.' Thus usage context is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description needs to carry the behavioral disclosure burden. It does so by stating the operation is read-only ('Return', 'Shows') and by explaining depth semantics ('1 = direct edges only'). It does not explicitly mention failure modes or prerequisites like needing an already-indexed graph, which is a minor gap.
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, front-loaded with the core action, and well-organized into summary, usage hint, args, and returns. Every section adds value and there is no filler or repetition beyond negligible redundancy between 'Return structural neighbors' and 'Shows which...'.
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 description covers the operation, argument semantics, depth behavior, and return shape ('Categorised list of neighboring nodes with their source locations'), and an output schema exists to handle return details. A true completeness gap is the implicit requirement that the codebase graph must already be indexed, given the sibling index_graph tool; mentioning that would make it fully self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description fully compensates: node_id is explained as 'Node ID or label substring' with examples, path is specified as 'Absolute path to the codebase root directory', and depth is defined as 'Number of hops to traverse' with direct-edge meaning and default. This adds substantial meaning beyond the bare schema.
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 a specific verb ('Return') and resource ('structural neighbors of a graph node'), then details exactly what kinds of relationships are included: calls, imports, containment, and inheritance. This makes it easy to distinguish from sibling tools like search_graph or 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?
It gives explicit sequential guidance: 'Use search_graph first to find the exact node ID.' This tells the agent how to prepare before calling, which is practically useful. It could go further and explicitly contrast when to use search_code or hybrid_search instead, but the neighbor-specific language makes the intended context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses ranking behavior ('most relevant'), scope over structural node labels, return contents (kind, source location, connectivity degree), and a hard dependency on index_graph. It does not mention error behavior if the graph is missing, but for a search tool this is reasonably transparent.
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 key behavior and prerequisite are front-loaded, followed by a compact Args/Returns breakdown. Every sentence adds information; the only minor redundancy is restating the default limit already present in the schema.
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 description is sufficient for a simple 3-parameter search tool: prerequisite, query semantics, limit, and return summary are covered, and an output schema exists for details. It could be more complete by stating behavior when index_graph has not been run and how results are ordered, but nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the Args section must carry the semantic weight, and it does. It explains query with concrete examples, path as the codebase root, and limit as maximum results with default. This is exactly the guidance an agent needs beyond the property titles.
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 opening line names a specific verb ('search'), a specific resource ('knowledge graph'), and a query criterion, and the next sentence narrows the target to node labels (function/class/file names), which distinguishes it from sibling search_code and graph_neighbors. This is enough for an agent to know what the tool matches and returns without opening the schema.
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 states the prerequisite ('codebase graph must be built first with index_graph') and gives query style examples. It does not name when-not-to-use alternatives, but it provides clear context about keyword-inside-labels vs code search, so an agent can infer the right situation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden. It discloses that the tool walks the directory, extracts nodes/edges, persists the graph to disk, and supports a force rebuild if a graph already exists. Core side effects are visible, even if performance costs and error behavior are not detailed.
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 tightly organized: a one-line summary, a brief mechanism paragraph, and clear Args/Returns sections. No sentence is wasted, and key concepts like independence from the vector index and force behavior are front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the essential invocation context: path requirements, force behavior, return summary (node count, edge count, files processed), and relationship to index_codebase. With the output schema already available, no additional return-structure detail is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description fully compensates by explaining both parameters: path is 'the absolute path to the codebase root directory' and force means 'rebuild the graph even if one already exists.' This provides complete, actionable meaning beyond the bare schema types.
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 opens with a specific verb and resource: 'Build (or rebuild) a knowledge graph for a codebase.' It further names the extraction outputs (structural nodes and edges) and explicitly mentions tree-sitter, which distinguishes it from vector-index siblings like index_codebase. The agent can confidently identify what this tool does without guessing.
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 clear context for how this tool relates to index_codebase ('same skip rules', 'independent of the vector index', 'run before or after'), which helps the agent understand ordering and sequencing. It does not explicitly say when to prefer this tool over graph query tools like search_graph or graph_neighbors, but it implies the build step clearly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/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 the internal mechanism (embedding + cosine similarity), the auto-indexing side effect, and the min_score filtering behavior. This goes well beyond a simple verb phrase and gives the agent confidence about what happens when called.
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 well-structured with a purpose statement, a short mechanism note, a clear args list, and a returns line. Every sentence contributes necessary information, and the most important scoping detail (semantic vs. other search) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity, the description covers what it does, how it behaves when the index is missing, all parameter details, and the return format. An output schema exists for the return shape, so listing field details is unnecessary. No essential information for calling it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it does thoroughly. Each of the four parameters is explained with type, default, and relevant examples or constraints (e.g., min_score semantics, max for top_k), adding significant meaning beyond the bare schema titles.
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 opens with a specific verb and resource: 'Semantically search an indexed codebase for code relevant to a query.' It clearly differentiates from sibling tools like search_graph or hybrid_search by explaining the embedding/cosine similarity mechanism, so an agent can tell what this tool uniquely does without opening a schema.
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 clear context: use it for natural-language semantic search over code, and it even notes that auto-indexing happens if needed. It does not explicitly name alternative tools or state when not to use it, but the context is strong enough that an agent can infer appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![vecgrep MCP server](https://glama.ai/mcp/servers/VecGrep/vecgrep/badges/card.svg)](https://glama.ai/mcp/servers/VecGrep/vecgrep)

Score Badge

Copy to your README.md:

[![vecgrep MCP server](https://glama.ai/mcp/servers/VecGrep/vecgrep/badges/score.svg)](https://glama.ai/mcp/servers/VecGrep/vecgrep)

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/VecGrep/vecgrep'

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