Qdrant RAG Build

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 clearly distinct roles, and the descriptions carefully separate collection lifecycle, ingestion, retrieval, and setup wizard operations. The search family is the main risk area: search, search_hybrid, search_rerank, search_multi_query, and get_context all overlap semantically, though their descriptions are precise enough to disambiguate with careful reading.
Naming Consistency3/5
The server uses readable lowercase snake_case throughout, but there is no single naming convention: object-first names like collection_list and document_list coexist with verb-first names like get_context and ingest_text, plus bare nouns such as health, stats, and job_status. Subfamilies are internally consistent, but the overall pattern is mixed.
Tool Count2/5
33 tools for a RAG build server is well past the 25+ 'too many' threshold. The tool count is inflated by an 8-tool search/retrieval family plus a setup wizard, profile system, and collection management layer, making the surface feel heavier than the core RAG job really requires.
Completeness4/5
The server covers the RAG lifecycle well: collection creation, ingestion from multiple sources, document management, snapshots, search, context assembly, setup wizardry, profiles, and health/stats. Minor gaps like no alias_delete or payload_index_delete are awkward but can be worked around without dead-ending an agent.
Average 4.2/5 across 33 of 33 tools scored. Lowest: 3.5/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 59 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotation contradiction: the description says 'Records the user's answer' which indicates a write/side-effect, while annotations declare readOnlyHint=true. That creates direct conflicting signals about whether this tool mutates session or wizard state. The description also shares validation behavior and returning a next step, but the contradiction dominates.
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-load the core action and return behavior while giving relevant validation examples. No filler or redundant restating of the tool name or 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?
Describes the flow (record, validate, return next question/null), mentions the 8-question limit, and indicates failure conditions via live validation. Because there is an output schema, return types need not be fully spelled out; a small gap is the missing detail on error behavior when riddances validation fails.
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%. The description adds meaning only for one parameter: 'answer' picks the answer for the current wizard question. It does not explain session_id at all, its structure, or how it controls the wizard state. The description does not compensate for the total lack of 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?
Describes a specific action (records the user's answer), a clear resource (the current wizard question), and the follow-up behavior (returns next question or null after all 8). This distinguishes it from sibling setup tools like setup_start or setup_apply, even without naming them.
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 clearly scopes use to an interactive 8-question wizard: call it when the user answers the current question, validate, then continue until the final answer is reached. It does not explicitly compare against alternatives like setup_start or setup_apply, so no exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool as read-only and non-destructive. The description reinforces this with 'Finds' and mentions the native similarity API, but adds little new behavioral context beyond what annotations provide, such as pagination, limits behavior, or response characteristics.
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 two sentences, front-loads the core action, and then gives the intended use case. Every part earn its place with no unnecessary detail.
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 is simple, has a clear output schema, and annotations already cover safety. The description sufficiently explains why the agent would call it, though it may still wish for a bit more detail on required parameters given the 0% schema description coverage.
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%, so the description must compensate. It only clarifies the intent behind 'point_id' ('given point', 'specific chunk') but provides no explanation for 'collection' or 'limit', leaving those parameters underspecified for the agent.
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 uses a specific verb and resource: 'Finds points similar to a given point by ID.' This makes the operation clear. However, it does not explicitly distinguish itself from the similarly vector-based sibling tools like 'recommend' or 'search' beyond the mention of point ID.
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 provides clear usage context: 'Use this to explore more like this starting from a specific chunk the user is looking at.' This tells the agent when to select this tool, but it does not explicitly name alternatives or state 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to establish that this is a safe read operation. The description adds useful behavioral context about fetching neighboring chunks within the same document, but it does not disclose output shape, boundary behavior, or what happens for invalid chunk indexes.
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 two sentences with no filler: the first sentence states what the tool does, and the second explains when to use it. It is front-loaded and every word contributes.
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?
The description is adequate for a simple, read-only tool with an output schema and annotations, but it relies on the agent inferring parameter meaning from names. The missing documentation of 'window' and of how chunk_index is sourced from get_context leaves a noticeable gap.
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%, so the description must compensate, but it only indirectly covers doc_id/collection through 'same document' and chunk_index via 'given result.' The window parameter, which controls how many chunks are fetched, is never explained, and collection/chunk_index formats are left undefined.
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 and resource: 'Fetches the chunks immediately before and after a given result within the same document, for continuity.' It also distinguishes the tool from get_context by naming it and describing the exact situation it addresses, so an agent can tell them apart.
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 an explicit trigger condition: 'Use this when get_context's answer references a chunk that seems to be cut off mid-thought.' This is clear context, but it does not state when not to use the tool or list other alternatives beyond get_context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already communicate non-read-only and non-destructive behavior. The description additionally clarifies that creating an index enables fast filtering, but it does not disclose what happens if the index already exists or whether this affects existing data. This is adequate but not rich.
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 two sentences, front-loads the core action, includes examples, and adds a practical usage condition. There is no fluff or repetition of schema details.
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?
The tool is a moderately simple three-parameter mutation and the description conveys its purpose and why to use it. However, because schema description coverage is 0%, the description should have provided more direct guidance on the value domains and how to populate the parameters correctly.
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%, so the description carries the burden of explaining the parameters. It broadly refers to a field such as date, author, or type, but it does not explain the exact meaning of collection, how field_type should be chosen, or how the parameter values relate to each other.
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 and resource: 'Creates a payload index on a collection field' and gives the intended purpose ('fast search filter'). It does not just restate the tool name and it is clearly distinguished from collection creation and 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?
The description gives an explicit trigger: use this when the wizard's filter question or a user request names a field that needs to be filterable. It provides clear context, though it does not explicitly say when not to use it or name an alternative tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish this as a read-only, non-destructive operation. The description adds useful ranking behavior context, such as RRF fusion and support for semantic plus exact/ID matches, but does not mention pagination, result behavior, or how filters interact with the search.
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?
One focused, front-loaded sentence communicates the core algorithm, the tool's default status, and the key use case. Every phrase earns its place with no repetition or filler.
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 read-only tool with an output schema, the description captures purpose, algorithm, and default routing—enough for a basic invocation. However, with many search siblings and unclear param semantics, the description is not fully complete for choosing between search, rerank, multi-query, or find_similar in edge cases.
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 does not explain 'collection', 'filters', or 'limit' semantics. It indirectly clarifies that 'query' is interpreted both semantically and as exact keyword/ID matches, which is useful but not enough to fully compensate for the 4 undocumented parameters.
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 names the operation ('search'), the mechanism ('Dense + sparse hybrid search with native RRF fusion'), and positions it as the recommended default search tool. This distinguishes it from sibling search tools even without naming them.
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 usage context: use it as the default for most queries because it covers both semantic and exact keyword/ID matching. It does not explicitly spell out when not to use it or which alternative to pick, so it stops short of a 5.
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?
The description accurately characterizes a writing, non-destructive ingestion and adds behavioral context: raw text goes into the semantic memory path, no source file is required, and metadata is optional. ReadOnlyHint=false and destructiveHint=false are respected, with no contradiction. It could disclose what happens if the target collection does not exist, but the annotations already cover the basic safety profile.
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 short, front-loaded, and easy to scan. The only minor waste is the conceptual repetition of not needing a source file and 'rather than pointing at a file' in the same sentence, which makes it slightly less lean than it could be.
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?
It is complete enough for a fairly simple ingestion task, especially because the tool appears in a family of related tools and has an output schema. However, it lacks guidance about collection preconditions and the 'source_label' parameter, which leaves an agent to guess a necessary part of the request when it is not optional and another when it is.
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%, so the description must compensate entirely for parameter meaning, but it only mentions raw text and optional metadata. The required 'collection' parameter is not explained (e.g., must it already exist?), and 'source_label' receives no semantic explanation at all. This is a real gap for a tool with 4 parameters.
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 identifies the action: ingesting raw text directly with optional metadata, and distinguishes itself from file-based ingestion by emphasizing 'without needing a source file.' It also names the key use case ('semantic memory') so an agent can separate it from sibling ingest tools without inspecting schemas.
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 tells the agent when to use it — for notes, pasted content, or text dictated in chat — and contrasts it with pointing at a file. It does not name the sibling tools that handle files, but the line 'rather than pointing at a file' sufficiently routes the agent toward ingest_file or ingest_directory as alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate a safe read-only and non-destructive operation, so the description does not need to restate that. It usefully adds that the tool invokes Qdrant's native recommendation API and explains the positive/negative example semantics. More behavioral detail such as pagination or ordering is not described, but that is acceptable given 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences: one states exactly what the tool does, and the second provides the main selection condition for when to use it. It is lean and front-loaded, with only a slight redundancy between 'recommends points' and 'point at examples'.
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 4-parameter read-only tool with an output schema and safe annotations, the description provides sufficient context: it names the mechanism, the expected input style, and the core positive/negative semantics. It stops short of exhaustively covering edge cases or alternative sibling routing, but the main operating context is fully represented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description has to carry meaning for the parameters. It gives good semantics for 'positive' as examples of what the user wants more of and 'negative' as what they want less of, and it establishes that these are point IDs. However, it does not explain the 'limit' or the 'collection' parameter, relying on the schema titles and defaults for those.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool Recommends points using positive and negative example point IDs via Qdrant's native recommendation API. It distinguishes this from text-query search by explicitly noting the trigger intent is pointing at examples, not phrasing a query.
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 a clear when-to-use condition: 'Use this when the user can point at examples of what they want more or less of.' It also implies when not to use it by saying 'rather than phrasing a text query', but it does not name sibling alternatives explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate the operation is not read-only and not destructive, and the description adds the useful context that the operation creates a safe point-in-time state. However, it does not disclose additional behaviors beyond the annotations, such as storage implications, performance impact, or whether the snapshot is immediate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first clearly defines the operation, and the second provides actionable context. There is no filler or 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?
For a simple one-parameter tool with an output schema, the description is largely complete: it names the operation, target, and typical scenarios. It does not mention how to later restore a snapshot or whether the snapshot id is returned, but those are covered by snapshot_restore and the output schema respectively.
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?
There is one required parameter, collection, with 0% schema description coverage, so the description should compensate with parameter guidance. The description only says the snapshot is 'of a collection', which adds almost nothing beyond the parameter name itself.
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 the exact operation (creates a point-in-time backup/snapshot) and the target resource (collection). It is clearly distinguishable from the related sibling snapshot_restore because it explicitly describes creation rather than restoration.
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 when-to-use guidance: before risky operations like bulk re-ingest or schema changes, or as part of routine backup cadence. It does not state when not to use the tool or list alternative snapshot-related tools, which keeps it just shy of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so no contradiction exists and the read-only nature is known. The description adds detail about the returned fields, which is helpful, but does not disclose additional behavioral traits such as error behavior, required permissions, or rate considerations.
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: two sentences with no filler. The first sentence states what the tool returns, and the second gives a concrete use-case. Information is front-loaded and every clause earns its place.
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 read-only tool with one parameter, an output schema, and clear annotations, the description provides enough for an agent to select and call it correctly. It could mention what happens when the collection does not exist, but this is a minor gap given the output schema exists.
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?
There is only one required parameter, 'name', and the schema description coverage is 0%. The description clarifies that the name refers to one collection, but does not explain naming constraints, formats, or how the value is used beyond the title already indicating it is a name.
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 and resource: 'Returns full detail on one collection,' and enumerates what is included: vector schema, payload indexes, size, and optimization status. This clearly distinguishes it from sibling tools like collection_list or collection_create.
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 when to use the tool: to inspect a specific collection's configuration, with a concrete example — deciding whether hybrid search or a given filter is available. It does not explicitly describe when not to use it or name alternatives, but the usage context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description goes beyond the input schema by clarifying the behavior of retrieving both the full document and partial page/section ranges, setting expectations about scope and output. It does not contradict 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences carry complete functional intent with no redundancy. The main retrieval behavior is front-loaded, and the usage context is at the end, making it easy to scan and process.
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?
The tool has an output schema, so return values do not need to be explained. However, with an input schema that has zero property descriptions, the tool description does not fully compensate: it does not clarify what 'collection' refers to or how the agent obtains a valid doc_id. For a simple retrieval tool with read-only annotations this is acceptable but still leaves a clear gap.
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%, so all parameter meaning should come from the description. It does explain the page_start/page_end semantics through 'page/section range,' but it leaves collection and doc_id entirely intuitive, with no explanation of how they relate to a citation or where the necessary values come from. This is inadequate with four parameters.
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 precise verb ('Retrieves'), a clear resource ('full original source document behind a citation', or a page/section range), and frames the tool in relation to citation context. This makes it easy for an agent to tell it apart from sibling retrieval tools like get_context or expand_context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use it: 'when the user wants more context than a single cited chunk provides.' It does not explicitly name an alternative tool or describe when not to use it, but the referenced use case gives solid guidance without requiring further inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already signal that this is a write operation that is not destructive. The description adds that ingestion involves format-specific quality processing, but it does not explain what this processing does, whether the collection must already exist, or whether an existing document is replaced or duplicated. The added context is modest rather than rich.
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 tight, front-loaded sentences: the main action and supported formats come first, and the single-file restriction is placed before the alternative tool. No redundant or filler wording is present.
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 core information for calling the tool is present: file type scope, one-file usage, and the destination collection. The output schema covers return expectations. It would be even better if it specified file path constraints, collection preconditions, or the nature of the quality processing, but the definition is not missing the critical invocation information.
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?
With 0% schema coverage, the description needs to define the parameters. It implicitly maps 'path' to a local file path and 'collection' to the destination collection, which helps, but it omits operational details such as whether the path must be absolute, whether the collection must exist, or how collection names are specified.
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?
Clearly states the verb 'ingests' and the exact resource: a single local file from an explicit list of formats into a collection. The scope is narrowed to one-at-a-time ingestion, which also differentiates it from ingest_directory even though other sibling ingest tools are not named.
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?
Gives an explicit usage boundary: 'Use this for one file at a time' and names the folder-level alternative ingest_directory. It does not explicitly mention ingest_text or ingest_url as alternatives for non-file inputs, but the enumerated file formats plus 'local file' make the intended use reasonably 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?
The description adds useful behavioral context beyond annotations: the tool makes an external network fetch and 'strips navigation/cookie-banners/footers' from the ingest content. Annotations only indicate it is not read-only and not destructive, so this extra detail about enrichment behavior is valuable. It doesn't mention potential network limits or external-access caveats, but what is disclosed is accurate.
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 front-load the primary capability, then immediately follow with concrete use cases. No extra filler or redundant restatements of the tool name.
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 two-parameter tool, the description is mostly complete, and the output schema covers return-value details. However, the 'collection' parameter is never explained, which is a real completeness gap since collection is required. The behavioral caveats about fetching external URLs are also minimal, but the simplicity of the tool keeps this from being a worse score.
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% for the two required parameters, so the description needed to compensate. It explains url semantically via 'Fetches a web page' but never explains the collection parameter—what it refers to, its format, or how it's related to the RAG. This leaves a required argument underdefined.
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 action (fetches a web page), resource (URL-addressable content), and outcome (ingests main content into the RAG). It also effectively distinguishes itself from sibling tools like ingest_text, ingest_file, and ingest_directory by focusing exclusively on URL sources.
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 applicability: 'Use this for documentation pages, articles, or any URL-addressable content the user wants in the RAG.' It doesn't explicitly name alternatives or exclusions, like 'prefer ingest_file for local files', but the URL-addressable scope makes the appropriate use case 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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a behavioral detail beyond annotations: the output is at source-document granularity rather than chunk granularity, which is important for interpreting results correctly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each adding distinct value: the first defines the tool's result and granularity, the second gives practical use cases. There is no filler and no redundant repetition of annotations or 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?
For a simple one-parameter, read-only tool with an output schema, the description provides enough context: what is listed, what granularity, and when to call it. The only substantive gap is the collection parameter semantics; safety and output shape are already covered by annotations and the output schema.
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?
The only required parameter, collection, has 0% schema description coverage, but the description only mentions it obliquely as 'in a collection.' It does not clarify whether the value should be a collection ID or name, how to format it, or how to find valid collections, so the description fails to compensate for the schema gap.
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 starts with a specific verb and resource: 'Lists ingested source documents in a collection' and immediately clarifies the granularity as one entry per original file/text/URL, not per chunk. This makes it easy to distinguish from chunk-level tools and from collection-level 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?
The description gives two concrete use cases: inspecting a collection before ingesting more and finding a doc_id for document_delete or get_document. It does not explicitly state when not to use the tool or contrast it with tools like collection_info or search, so it misses the explicit exclusion needed for a 5.
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?
The description adds useful behavioral context beyond the annotations: this is a stateful action that changes which collection and embedding configuration all subsequent tool calls will use. It does not contradict readOnlyHint=false or destructiveHint=false. It could disclose more about failures (e.g., unknown profile name) or reversibility, but the core behavior is clearly conveyed.
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 two sentences with no filler. The primary behavior is front-loaded, and the example follows naturally to clarify intended use.
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?
For a one-parameter, stateful switching tool, this description is complete enough. It explains the effect, the use case, and provides an example; with an output schema present, no return-style documentation is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It implies the single `name` parameter is the identifier of a saved profile and provides real examples like 'demo' and 'work'. However, it never explicitly maps `name` to the parameter or states constraints such as whether the profile must pre-exist.
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 uses a specific verb and resource: it activates a saved profile and explains the effect is switching the active collection and embedding configuration for subsequent tool calls. It is clearly distinct from listing profiles or creating collections, though it does not explicitly name a sibling it should be distinguished from.
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 clearly tells the user when to use it: to switch between separate RAG setups, with a concrete 'demo' to 'work' example. It does not state when not to use it or name alternatives, but the intended usage context is unambiguous.
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?
The annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful behavioral nuance: the caller supplies the reformulations, several queries are executed, and hybrid results are fused into a single ranking. This goes beyond purely restating the 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 sentences with no filler. The first sentence states how it behaves, the second gives a concrete use case with examples. Everything earned its place.
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?
With an output schema present, read-only annotations, and the core parameter (queries) explained, the description is mostly complete for an agent deciding to invoke it. The main gap is around filters and how they interact with the multiple query variants, but the overall tool usage is understandable.
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%, so the description carries the burden of explaining parameters. It usefully clarifies the 'queries' parameter as LLM-supplied reformulations and shows a combined result, but it does not explain 'collection', 'limit' scope, or 'filters'/format semantics or how filters apply across multiple queries at any extension.
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 operation: run multiple query reformulations and fuse their hybrid results into one ranking. This clearly differentiates it from single-query sibling tools like search and search_hybrid.
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 gives a selection rationale: 'Use this when a single query phrasing might miss relevant chunks — e.g. ambiguous or broad questions.' It lacks an explicit list of when-not-to-use or naming of alternative tools, so it does not reach the full 5.
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?
The description explains the underlying behavior beyond the annotations: clients continue querying the alias while the collection is swapped, which reinforces the non-destructive mutation implied by the annotations. It doesn't mention side effects on the old collection, but still provides meaningful behavioral context.
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 two tight sentences with the verb/action and use case front-loaded. There is no redundant phrasing or repetition of the tool name, and every clause adds context.
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 two simple string parameters and an existing output schema, the description gives enough context about when and how to use the tool. It could mention whether the alias or collection must already exist, but the core operation, purpose, and invocation context are sufficiently covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description alone must clarify parameters. It conveys that 'alias' is the stable endpoint clients query and 'collection' is the target being pointed to, which adds relationship meaning. Even so, it doesn't specify exact value formats, whether names or IDs are expected, or any option 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 uses a specific action and resource pair ('Points an alias at a collection') and immediately adds the practical goal: zero-downtime blue/green re-indexing. This distinguishes it from general collection creation/deletion tools or search operations and makes the tool's role unambiguous.
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 an explicit use case: 'Use this when republishing a freshly re-indexed collection without downtime.' It does not explicitly mention when not to use it or suggest alternatives, so it stops just short of complete routing 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?
The annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds a valuable behavioral detail: secrets such as API keys and bearer tokens are masked in the output. This goes beyond the annotations and warns the agent that the response has sanitized values.
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 and front-loaded: it states the main behavioral contract first, then adds the credential-masking guarantee. Every sentence adds value, and there is no redundant or filler content.
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?
For a zero-parameter, read-only tool with an output schema available, the description is complete. It identifies what is returned, the intended use, and the critical masking behavior, so an agent has enough information to invoke the tool correctly and interpret expectations.
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?
The input schema has zero parameters, so the description does not need to describe parameter behavior. The description clarifies that no input is required and that the tool operates on the currently active profile, which is sufficient context for a parameterless tool.
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 returns the effective configuration of the active profile, which is specific and actionable. It implies a distinction from sibling tools like profile_list and profile_use, but it does not explicitly differentiate itself from them.
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 a clear intended use: 'confirm what's actually configured without ever exposing credentials.' It does not explicitly state when not to use it or mention alternatives, but the guidance is strong enough for an agent to recognize the appropriate use case.
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?
Annotations only indicate readOnly=false and destructive=false, so the description carries the behavioral burden. It adds useful context by stating that ingestion is a background-trackable job and that progress should be polled via job_status, which is not visible from the annotations or schema alone. It does not detail duplicate handling or error cases, but it covers the key async behavior.
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 two sentences and contains no filler. The core operation is front-loaded, and the follow-up guidance about polling job_status is placed at the end. Every sentence either clarifies behavior or directs the agent to the correct follow-up tool.
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 this tool's complexity, the description gives enough to confidently invoke it: it identifies the target resource, optional filters, and the asynchronous tracking mechanism. An output schema exists, so return-value details need not be explained. The only notable gap is that 'collection' is a required parameter and receives no explanation beyond its name.
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 schema has no descriptions for parameters; the description partially compensates by mentioning local directory, optional glob include/exclude patterns, and bulk ingestion. However, it does not explain the semantics of the required 'collection' parameter beyond the tool's general intent, and it does not specify glob syntax. It adds value but does not fully compensate for the 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 clearly states a specific verb ('recursively ingests'), a concrete resource ('every supported file under a local directory'), and a clear distinguishing scope: bulk directory ingestion. Given sibling tools like ingest_text, ingest_file, and ingest_url, this description makes the directory-based focus immediately obvious.
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 tells the agent when to use it: 'Use this for bulk ingestion of a folder; poll job_status for progress.' This provides a clear usage context. It does not explicitly name or exclude the sibling ingest tools, but the bulk-vs-single distinction is strongly implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful detail that the tool returns basic size info for each collection, but it does not add deeper behavioral context such as pagination or potentially large responses. With annotations covering the core behavior, a 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The main action is up front, the scope is explicit, and the usage guidance is integrated without bloating the description.
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?
For a zero-parameter, read-only listing operation with an output schema present, the description fully covers what the agent needs to decide when to call this tool. Nothing important is missing.
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?
This tool has zero parameters and the schema covers everything trivially, so the description has little to add. The baseline for a zero-parameter tool is 4, and the description's mention of 'which collection' selection is sensible even though no parameters are needed here.
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 and resource ('Lists every Qdrant collection') and adds scope ('managed by this server') plus a hint of return content ('basic size info'). It effectively distinguishes itself from collection_info (single collection) and collection_create by focusing on enumeration of all collections.
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 provides clear usage context: use it to see existing RAG collections before creating a new one or choosing which to search. It does not explicitly name alternative tools or say when not to use it, but the use-case guidance is strong enough to guide an agent.
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?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: this is a polling operation, and 'completed' only means counters reconcile with expectations. That is valuable for an agent deciding when to stop polling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words. The core purpose is front-loaded, and the second sentence adds essential polling behavior without redundancy.
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 a single parameter, read-only annotations, and an existing output schema, this description is complete for an agent to call the tool. It explains the polling use case and the definition of completion, leaving no critical gap.
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 schema offers no description for job_id, so the description carries the burden. It establishes that job_id refers to a background ingestion job started by ingest_directory, which is useful, but it does not explicitly say how to obtain or format the ID. It is adequate for a single obvious parameter but not fully explicit.
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 ('checks') and resource ('progress of a background ingestion job started by ingest_directory'). This clearly identifies what the tool does and naturally distinguishes it from ingestion and search siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use this for polling a long-running bulk ingest rather than assuming completion, and explains the completion condition. It does not list explicit alternative tools, but the 'started by ingest_directory' framing gives clear contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to restate safety. It adds contextual value about saved profiles but discloses no extra behavioral traits such as rate limits or ordering. The description does not contradict 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, focused sentences. The main action is front-loaded, examples are included for clarity, and there is no redundant filler.
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 tool is a simple list with no parameters and the output schema is already available, so the description fully covers what an agent needs: why to call it, what it returns, and when to use it.
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?
The tool has zero parameters and no schema properties. With 0 params the baseline is 4; the description reinforces that the tool lists existing profiles but adds no specific parameter details, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource combination: "Lists saved configuration profiles," and adds concrete examples (demo, work, project X). It distinguishes itself from switching tools by stating its role as discovering what exists before creating or switching, which separates it from the sibling profile_use.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use it before creating a new profile or switching profiles. This provides clear context, though it does not name the alternative tool (e.g., profile_use) by name, so it gets a 4 rather than a 5.
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?
Annotations already establish that this is read-only and non-destructive, so the description does not need to restate that. It adds useful behavioral context by naming the pipeline two stages and a key price/latency. This goes beyond the structured annotations and helps an agent understand operational trade-offs.
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, no filler, no repetition of schema or annotations. The mechanism is described first, then the usage policy, so the most identifying information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only search tool with an output schema, this is mostly complete: the agent knows what happens and when to use it, and the output returns is already covered by the schema. It loses a point because the description does not clarify the precise meanings of several parameters, meaning an agent might still guess on limit versus rerank_top_n.
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%, so the description is expected to compensate for the parameter semantics. It only gives a general sense of 'top results', which loosely hints at the role of limit and rerank_top_n, but does not clarify how filters, collection, limit, or rerank_top_n individually behave. The meaning of rerank_top_n, in particular, remains ambiguous.
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 operation: hybrid search followed by cross-encoder reranking. It also communicates the value proposition, maximum precision at extra latency, making it easy to distinguish from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides an when-to-use rule: use it when result quality matters more than speed. It also gives a counterexample ('exploratory search') to discourage misuse, making the selection criteria clear even without naming specific alternatives.
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?
Annotations indicate this is a write operation but not destructive; the description goes beyond this by explaining what the tool configures by default (named vectors and payload indexes) and that it creates a fresh, standalone collection. It adds useful behavioral context such as the intended one-time usage per document set.
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 two sentences, front-loaded with the core action, and every clause adds useful information. There is no filler or repetition of schema 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?
Given two simple parameters and an output schema, the description covers the core purpose, usage boundary, and default behavior well. A minor gap is the lack of guidance about what differentiates the presets or what happens if a collection with the same name already exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, and it partially does by explaining that 'name' is a collection name tied to a new document set and 'preset' selects dense, hybrid, or multitenant. However, it does not explain what each preset actually changes or how the name should be formatted, so the parameter semantics are only partially fleshed out.
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 that this tool creates a new Qdrant collection, names the available presets, and says it configures named vectors and payload indexes by default. It also distinguishes this operation from adding documents, making its scope unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use this tool once per new document set needing its own collection, and explicitly tells the agent not to use it for adding documents to an existing collection, directing it to ingest_* tools instead.
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?
Annotations already declare this read-only and non-destructive, and the description adds useful behavioral context: it does not ingest content, it produces an estimate, and cost is only included if a paid provider is configured. This complements rather than contradicts 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the purpose, lists the key outputs, mentions the cost dependency, and ends with a practical use case. Every clause is relevant and there is no filler.
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?
With an output schema present, the description need not explain the return structure. It covers the what, when, and why of usage, and is complemented by read-only annotations. A small omission is whether directory paths are processed recursively, but this is minor for a preview/estimate 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?
The schema's only parameter is a bare 'path' with 0% schema description coverage. The description compensates by clarifying that the path refers to a file or directory, which resolves the main ambiguity. More detail about path format or resolution would help, but this is sufficient for a single-parameter tool.
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 lead verb 'estimates' identifies a specific analysis action on a file or directory, and the description defines exactly what is estimated: chunk count, storage, and embedding cost. Framing it as 'Before ingesting' clearly distinguishes it from ingest_* siblings.
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 when to use the tool: 'before a large ingest, preview before committing.' It does not explicitly list exclusions or name alternatives, but the context is clear and actionable.
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?
Annotations already cover the read-only, non-destructive safety profile. The description adds meaningful behavior context: it is a 'plain dense semantic search' (not hybrid or reranked), and it emphasizes speed and simplicity. This goes beyond merely restating annotations, though it stops short of detailing filter syntax or limit behavior.
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 dense sentences deliver scope, routing guidance, and behavioral characterization with zero filler. The main instruction is front-loaded and the comparison to alternatives is placed near the end without bloat.
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, read-only search tool with an output schema present, this description sufficiently identifies the operation and key distinguishing traits. It does not repeat return-value details (correctly leaving that to the output schema), and the sibling context is large but the routing guidance handles that well. Minor gaps around filter payload details prevent a 5.
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 the description carries the burden. It clarifies that `collection` is the target collection and `filters` are optional payload filters, and query is implied by 'semantic search.' However, it does not explain the format or constraints of `filters` or highlight `limit` semantics, leaving some ambiguity for the agent.
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 clear, specific verb/resource pair: 'dense semantic search over a collection' with optional payload filters. It distinguishes this from siblings like search_hybrid and search_rerank by scoping it to plain dense search without fusion or reranking.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool ('fast, simple similarity search when hybrid fusion or reranking isn't needed') and when not to ('for most RAG questions, prefer get_context or search_hybrid instead'). This is exemplary routing 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?
The description discloses the exact mutation surface: creating resources, ingesting a document, and running a smoke-test search, which aligns with readOnlyHint=false and destructiveHint=false. It does not state behavior on rerun or failure (e.g., whether resources already exist), but for a created resources this is a minor gap rather than a contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the first lists the action plan, the second gives an unambiguous usage precondition. Every clause contributes to correct invocation, and the description is front-loaded with the operational effect.
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?
With an output schema present, the description doesn't need to explain return values, and it already covers what the plan does and when to run it. It could be more explicit about what identifies the session in parameters, but the description provides the key context an agent needs to avoid mis-use.
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 the description must compensate, but it never explicitly documents the 'session_id' parameter semantics. However, the mention of 'setup_answer' and 'session is complete' strongly implies session_id identifies the in-progress setup wizard, providing enough inference for a single self-descriptive parameter.
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 ('Executes'), a specific resource ('fully agreed wizard plan'), and enumerates the concrete side effects: creates collection, indexes, profile, ingests an example document, and runs a smoke-test search. This clearly distinguishes setup_apply from sibling tools like setup_start and setup_answer by positioning it as the final plan-execution step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit conditional usage: 'Use this only after setup_answer has returned all 8 questions answered — never before the session is complete.' It names the prerequisite sibling and provides an exclusion condition, leaving no ambiguity about when the tool should be called.
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?
The description adds behavioral context beyond the read-only/destructive annotations by explaining that this is a diagnostics-only tool reporting status and configuration states. It does not state any side effects or requirements, but with readOnlyHint=true and no parameters, nothing more is strictly necessary.
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, front-loaded with the tool's purpose, and wastes no words. The first sentence enumerates specific status items, and the second sentence gives a clean usage directive.
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?
For a zero-parameter read-only health check with a provided output schema, the description provides everything needed: the exact data points reported and the situations in which to call it. No important context is missing.
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?
The tool has zero parameters, so there is no schema burden at all. The description does not need to explain parameter semantics, and the baseline for zero-parameter tools is appropriately met.
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 ('Reports') and defines the resource scope: Qdrant connectivity, embedding model, reranker status, server version, and active transport. This makes it clear what the tool does and how it differs from other health-adjacent tools in the sibling list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use the tool: first when something seems broken, or to confirm the server is reachable and correctly configured. It does not explicitly name alternatives or exclusion conditions, but the usage context is clear enough for an agent.
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?
Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond that: it is an aggregate reporting operation, scoped to all or one collection, and lists what the stats include. No unexpected side effects or hidden mutation behavior are implied.
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 two tight sentences: the first gives scope, behavior, and outputs; the second gives the canonical use case. There is no filler, repetition, or unnecessary detail.
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 is simple (one optional parameter), read-only, and has an output schema, the description is complete enough for an agent to select and invoke it correctly. It covers the scoping behavior, the metrics, and the intended question type; no additional context is missing.
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?
The input schema only describes 'collection' as string/null with a default of null and provides no property description. The description compensates by supplying the essential semantics: omit it to get stats across all collections, or name one to restrict to a single collection. It leaves out name-format details, but for a single optional string parameter this is sufficient.
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 ('reports') and resource ('usage stats across all collections'), lists concrete outputs (point counts, document counts, disk size, distribution by source type), and notes the optional single-collection scope. This clearly differentiates it from sibling tools like collection_list or collection_info, which are about listing or inspecting collections rather than aggregating usage.
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 a clear, actionable use case: answer 'how much do I have in my RAG' style questions. It also clarifies the all-versus-one-collection behavior for the optional parameter. However, it does not explicitly mention when not to use it or name alternative tools for related needs.
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?
Even though readOnlyHint and destructiveHint already communicate safety, the description adds valuable behavioral detail beyond annotations: it performs hybrid search, reranks, applies MMR, enforces a token budget, and structures output for direct LLM answering.
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 dense but efficient: the first sentence describes behavior and output, and the second provides actionable selection guidance. No filler is present.
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?
Combined with the output schema and read-only annotations, the description gives the agent enough understanding of the tool's purpose, behavior, and usage context. There is little risk of selecting the wrong retrieval tool.
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%, so the description needed to compensate, but it only meaningfully explains the token budget and implicitly the query. Filters and collection are left to name inference, which is not enough for fully reliable invocations.
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 names a concrete operation (hybrid retrieval with reranking and MMR) and a clear deliverable (a formatted context block with numbered citations), making it easy to distinguish get_context from the raw search_* siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to prefer this tool over raw search_* tools when the goal is to answer a question rather than inspect search results, giving both a clear when and a clear when-not signal.
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?
Beyond the annotations, the description discloses that deletion is permanent, removes all data, requires confirm_name to exactly match name, and is blocked in read-only server mode. This is strong behavioral context and does not contradict annotations.
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 concise, front-loaded sentences. Every sentence adds useful information: permanent deletion, destruction, confirmation, read-only block, and user-confirmation guard. No redundant text.
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?
For a two-parameter destructive tool with annotations and output schema, the description covers all essential behavior, including irreversibility, the guard to prevent accidental deletion, and operating restrictions. The agent can safely invoke this tool without needing further context.
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 must compensate. It clarifies that confirm_name must exactly match name and that name identifies the Qdrant collection. It could list each parameter separately, but the critical confirmation relationship is explicit and sufficient.
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 and resource: 'Permanently deletes a Qdrant collection and all its data'. This clearly distinguishes collection_delete from siblings like collection_create, collection_list, collection_info, and document_delete.
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 states when to use the tool: only after the user explicitly confirms deletion. It also mentions the read-only mode block and confirmation-match requirement. It does not mention alternative actions like backup or snapshot-restore, but for a destructive delete the main safety guidance is 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?
Annotations already communicate readOnlyHint=true and destructiveHint=false, so the safety burden is minimal. The description adds useful behavioral context: it is a one-time opener, returns the first question rather than an answer, and implies that later steps go through sibling tools. There is no contradiction with annotations because the 'session' is conversational, not a persistent data write.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The first sentence delivers the core action and return value; the second provides the placement rule. The most decision-relevant information is fully 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?
For a zero-parameter tool with an output schema and non-destructive annotations, the description is complete. It captures purpose, result, and sequencing constraints; nothing needed to call this tool correctly is missing.
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?
The input schema declares no parameters, so there is nothing for the description to add at the parameter level. The zero-parameter baseline of 4 applies, and the description correctly focuses on behavior instead.
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 it 'Starts a new conversational setup session' and specifies the concrete return value: 'the first question, with options and a recommended default.' This clearly disambiguates it from later-step siblings like setup_answer and setup_apply.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is explicitly scoped: 'Use this once, at the very beginning' and a strong when-not condition: 'never mid-conversation once a session is already in progress.' The agent knows exactly when this tool belongs in the flow.
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?
The annotations already mark the tool as destructive and non-read-only, but the description adds valuable safety behavior: overwriting current contents, requiring an exact confirm_name match, being blocked in read-only mode, and requiring explicit user confirmation. This is strong behavioral disclosure 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three crisp sentences with no filler. The destructive warning and confirmation condition are foregrounded, and each sentence adds meaningful information.
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?
With an output schema available and annotations covering read-only and destructive hints, the description supplies the remaining operational context: overwrite behavior, confirmation requirement, and read-only blocking. An agent has enough to invoke this safely.
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 must carry the parameter semantics burden. It explains confirm_name's exact-match requirement and the collection target, and snapshot_name is implied as the previously created snapshot. All three required parameters are inferable, though not formally parameter-by-parameter documented.
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?
Clearly states the action: restore a collection from a previously created snapshot and overwrite current contents. It is distinct from snapshot_create and collection_delete based on this description alone.
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?
States a clear guardrail: only use when the user has explicitly confirmed the overwrite. It also says read-only mode blocks the operation. It does not name contrasting use cases such as when snapshot_create or collection_delete would be more appropriate, so it falls just short of full explicit alternative guidance.
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?
Annotations already signal destructive behavior, but the description adds crucial context: the deletion is scoped to one document's chunks, confirmation requires an exact doc_id match, the tool is disabled in read-only mode, and it must only be used after explicit user confirmation. No contradiction with 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Every sentence earns its place. It front-loads the core action and scope, then adds the safety constraints in a compact and readable way. No redundant filler.
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?
For a destructive, three-parameter tool, the description conveys scope, safety guards, preconditions, and when and when not to invoke it. An output schema is present, so not describing the return format is acceptable. The agent has everything needed to safely choose and call this 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 coverage is 0%, so the description must compensate for the bare parameter names. It explains confirm_doc_id's role as a guard requiring an exact match with doc_id, and it clarifies that the deletion acts on chunks of a single document within a collection. It does not elaborate on the collection parameter, but its meaning is recoverable from context and the param name.
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?
States a specific verb ('Deletes') and resource ('every chunk belonging to one source document from a collection'), and clearly distinguishes this from collection-level deletion. The phrase 'every chunk belonging to one source document' makes the tool's exact scope immediately obvious, and 'without touching the rest' removes ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells the agent when to use the tool: only when the user has explicitly confirmed deletion. It also states when not to use it: in read-only mode, and when confirm_doc_id does not exactly match doc_id. This is strong usage guidance for a destructive operation.
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:

[![RAG-Build MCP server](https://glama.ai/mcp/servers/avaazquezz/RAG-Build/badges/card.svg)](https://glama.ai/mcp/servers/avaazquezz/RAG-Build)

Score Badge

Copy to your README.md:

[![RAG-Build MCP server](https://glama.ai/mcp/servers/avaazquezz/RAG-Build/badges/score.svg)](https://glama.ai/mcp/servers/avaazquezz/RAG-Build)

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/avaazquezz/RAG-Build'

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