Delia

by zbrdc

Overview Schema Related Servers Score Discussions

Python

Hybrid

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation3/5
There is significant overlap between several tools, particularly 'delegate' and 'think', which both handle complex reasoning tasks with similar routing logic, and 'batch' which essentially parallelizes 'delegate' tasks. However, descriptions clarify distinctions: 'delegate' is for single tasks, 'think' emphasizes deep reasoning, and 'batch' is for parallel execution. Other tools like 'health', 'models', and 'queue_status' have distinct monitoring purposes.
Naming Consistency4/5
Most tools use clear, consistent snake_case naming (e.g., 'get_model_info_tool', 'switch_backend', 'queue_status'), with descriptive verbs like 'get', 'switch', and 'think'. The only minor deviation is 'get_model_info_tool', which includes 'tool' redundantly, but overall the naming is predictable and readable across the set.
Tool Count5/5
With 9 tools, the count is well-scoped for a GPU/LLM management server. Each tool serves a distinct role: execution ('delegate', 'batch', 'think'), configuration ('switch_backend', 'switch_model'), and monitoring ('health', 'models', 'queue_status', 'get_model_info_tool'). No tool feels unnecessary, and the set covers core operations without being overwhelming.
Completeness5/5
The tool surface comprehensively covers the domain of GPU/LLM task execution and management. It includes task execution ('delegate', 'batch', 'think'), model and backend configuration ('switch_backend', 'switch_model'), and full monitoring ('health', 'models', 'queue_status', 'get_model_info_tool'). There are no obvious gaps; agents can manage the entire lifecycle from setup to execution to oversight.
Average 4.4/5 across 9 of 9 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that backend_id comes 'from settings.json' and returns a 'confirmation message with current status', which adds some context. However, it lacks critical details: whether this requires specific permissions, if it's a destructive change affecting ongoing processes, rate limits, or error conditions. For a mutation tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise. It front-loads the purpose in the first sentence, followed by clear 'Args' and 'Returns' sections. Every sentence earns its place by providing essential information without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with one parameter) and the presence of an output schema (which handles return values), the description is minimally complete. It covers the purpose and parameter semantics but lacks behavioral context and usage guidelines. With no annotations, it should do more to explain permissions, side effects, or error handling for a backend-switching operation.
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 description coverage is 0%, so the description must compensate. It adds meaningful semantics: 'backend_id' is described as 'ID of the backend to switch to (from settings.json)', clarifying the source and purpose beyond the bare schema. Since there's only one parameter, this adequately covers its semantics, though it doesn't specify format or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Switch the active LLM backend.' This is a specific verb ('switch') with a clear resource ('active LLM backend'). However, it doesn't explicitly differentiate from its sibling 'switch_model' (which might switch models within a backend), leaving some ambiguity about sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to know backend IDs from settings.json), exclusions, or compare it to sibling tools like 'switch_model' or 'models'. The agent must infer usage context solely from the purpose statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context beyond basic functionality: it explains that changes are 'persisted to settings.json for consistency across restarts,' which is a key behavioral trait not inferable from the schema. However, it doesn't cover potential side effects, error conditions, or permissions needed, keeping it from a perfect score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It starts with a clear purpose statement, followed by context sentences that earn their place by explaining benefits and persistence. The 'Args' and 'Returns' sections are front-loaded with critical information, and there is no redundant or wasteful text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (runtime model switching with persistence), no annotations, and an output schema present (which handles return values), the description is mostly complete. It covers purpose, parameters, and key behavioral context. However, it lacks details on error handling or integration with sibling tools, preventing a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate fully. It does so effectively: the 'Args' section clearly defines both parameters ('tier' and 'model_name'), including allowed values for 'tier' ('quick', 'coder', 'moe', or 'thinking') and constraints for 'model_name' ('must be available in the current backend'). This adds essential meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Switch the model for a specific tier at runtime.' It specifies the verb ('switch'), resource ('model'), and scope ('for a specific tier'), making the action clear. However, it doesn't explicitly differentiate from sibling tools like 'switch_backend' or 'get_model_info_tool', which would be needed for a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some implied usage context: 'This allows dynamic model experimentation without restarting the server' suggests when to use it (for runtime model changes). However, it doesn't explicitly state when to use this tool versus alternatives like 'switch_backend' or 'models', nor does it mention prerequisites or exclusions, leaving gaps in 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool returns (queue status, loaded models, pending requests, GPU memory usage) and its monitoring/debugging purpose. However, it lacks details on potential side effects (e.g., if it's read-only, performance impact, or rate limits), which would be valuable given the absence of 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 well-structured and concise, with three short paragraphs that front-load the purpose, provide usage context, and specify the return format. Every sentence adds value without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (monitoring system status), no annotations, and the presence of an output schema (which handles return value details), the description is complete. It covers the tool's purpose, usage scenarios, and high-level output structure, leaving technical specifics to the output schema, which is appropriate.
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 0 parameters, and the schema description coverage is 100%, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and output without unnecessary parameter details, earning a high baseline score for this dimension.
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's purpose with a specific verb ('Get') and resource ('current status of the model queue system'). It distinguishes itself from siblings like 'health' (general system health), 'models' (likely listing models), and 'get_model_info_tool' (specific model details) by focusing exclusively on queue status, loaded models, and queued requests.
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 context for when to use the tool ('Useful for monitoring queue performance and debugging loading issues'), which helps differentiate it from siblings. However, it does not explicitly state when NOT to use it or name specific alternatives (e.g., 'health' for broader system status), keeping it from a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: it returns detailed model information, distinguishes between configured models (exact values) and unknown models (estimates), and specifies the return format. This covers the tool's functionality and output behavior well, though it doesn't mention potential errors or rate limits.
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 appropriately sized and front-loaded, with the core purpose stated first, followed by key behavioral details, and then structured sections for Args and Returns. Every sentence earns its place by adding essential information without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, informational purpose), no annotations, and the presence of an output schema (which handles return values), the description is complete enough. It covers purpose, usage context, parameter semantics, and behavioral traits, providing all necessary context for an AI agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate fully. It does this excellently by clearly explaining the single parameter 'model_name', providing its purpose ('Name of the model to get info for') and concrete examples ('e.g., "qwen2.5:14b", "llama3.1:70b"'), adding significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get detailed information') and resource ('about a specific model'), distinguishing it from siblings like 'models' (likely listing models) or 'switch_model' (changing models). It explicitly identifies what information will be retrieved: VRAM requirements, context window size, and tier classification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by specifying it's for getting information about 'a specific model', suggesting it should be used when detailed model specs are needed. However, it doesn't explicitly state when to use this tool versus alternatives like 'models' (which might list available models) or provide clear exclusions or prerequisites for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does so well by detailing routing logic (distribution across GPUs, handling large content, round-robin, backend health), performance implications (maximum throughput), and return format (combined results with timing and routing info). It doesn't mention rate limits or auth needs, but covers key behavioral traits thoroughly.
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 well-structured with clear sections (description, usage, args, routing, returns, example) and front-loaded key information. It's appropriately sized for a complex tool, though slightly verbose; every sentence adds value, such as the routing logic details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (parallel execution, routing logic) and no annotations, the description is complete: it covers purpose, usage, parameters, behavior, and returns. With an output schema present, it needn't detail return values, but still provides useful context like timing and routing info, making it fully adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate fully. It does by explaining the 'tasks' parameter as a JSON string with an array of task objects, detailing each object's fields (task types, content, file, model, language), including enums and requirements. This adds comprehensive meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool executes multiple tasks in parallel across GPUs for maximum throughput, specifying the verb 'execute' and resource 'tasks' with the key characteristic of parallel distribution. It distinguishes from siblings like 'delegate' or 'queue_status' by emphasizing parallel execution rather than sequential delegation or status checking.
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 'WHEN TO USE' section explicitly lists scenarios for using this tool: processing multiple files simultaneously, bulk operations like code review, and any parallelizable workload. It implicitly contrasts with non-parallel siblings by highlighting parallel execution, though it doesn't name 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?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it only checks enabled backends, shows availability/loaded models/usage stats/cost savings, and returns specific JSON structure. It doesn't mention rate limits or authentication requirements, but covers most operational aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, constraints, usage scenarios, return format), front-loads the core purpose, and every sentence adds value without redundancy. The bulleted lists enhance readability without wasting space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's diagnostic nature, 0 parameters, no annotations, but with an output schema (implied by the detailed 'Returns' section), the description provides complete context: purpose, constraints, usage guidelines, and detailed return structure, making it fully self-contained for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately notes there are no parameters by not discussing any, which is correct for this parameterless 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 description clearly states the specific action ('Check health status') and resources ('Delia and all configured GPU backends'), distinguishing it from siblings like 'queue_status' or 'get_model_info_tool' by focusing on system-wide health rather than specific queue or model details.
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 'WHEN TO USE' section explicitly lists four scenarios for using this tool, including verifying backend availability before delegation and diagnosing connection issues, providing clear guidance on when to select this tool over 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?
With no annotations provided, the description carries the full burden. It effectively discloses key behavioral traits: it's a read-only operation (implied by 'List'), it shows loaded vs. configured status, and it includes routing logic. However, it doesn't mention potential limitations like rate limits or authentication needs, which could be relevant for a tool querying system resources.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage guidelines, returns) and front-loaded key information. Every sentence adds value: the first defines the tool, the 'WHEN TO USE' bullets provide context, and the 'Returns' section clarifies output 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 the tool's low complexity (0 parameters, no annotations, but has output schema), the description is complete. It explains what the tool does, when to use it, and what it returns, with the output schema handling detailed return structure. This covers all necessary context for a simple listing 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 tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and output, which is correct for a parameterless 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 description clearly states the specific action ('List all configured models') and resource ('across all GPU backends'), distinguishing it from siblings like 'get_model_info_tool' (likely for single model details) and 'switch_model' (for changing models). It also specifies what information is included: model tiers and loaded status.
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 'WHEN TO USE' section explicitly lists three scenarios for using this tool: checking available models, verifying configurations, and understanding routing logic. This provides clear guidance on when to use it versus alternatives like 'get_model_info_tool' for detailed info on a specific model.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and delivers substantial behavioral context: it explains computational resource usage ('local GPU', 'falls back to remote'), cost implications ('zero API costs'), model selection logic based on depth, and automatic thinking mode activation. It doesn't mention rate limits or error handling, but covers most key behavioral aspects.
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 well-structured with clear sections (purpose, usage guidelines, args, routing, returns, examples) and front-loaded key information. While comprehensive, some sections like 'ROUTING' could be more concise, but overall it maintains good information density with minimal 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 the tool's complexity (reasoning engine with resource management), no annotations, and 0% schema coverage, the description provides exceptional completeness: it covers purpose, usage, parameters, behavioral traits, routing logic, return format, and examples. The presence of an output schema reduces need to explain returns, and the description fills all other gaps effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by providing detailed parameter semantics: it explains each parameter's purpose, marks 'problem' as required, describes 'context' as supporting information, and provides a comprehensive breakdown of 'depth' values with model specifications and behavior differences. This adds significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Deep reasoning for complex problems using local GPU with extended thinking' and distinguishes it from siblings by specifying it's for 'complex multi-step problems requiring careful reasoning' rather than batch processing, delegation, or system operations. It explicitly contrasts with quick actions by emphasizing extended thinking.
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 includes a dedicated 'WHEN TO USE' section with explicit guidance: it lists specific use cases (architecture decisions, debugging strategies), provides clear alternatives (different depth levels), and distinguishes when to use this tool versus other approaches. The examples further clarify appropriate contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and delivers comprehensive behavioral disclosure. It explains the 3-tier model selection logic, routing decisions based on content size and GPU availability, fallback mechanisms, load balancing, and what the return includes (metadata footer). This goes well beyond basic function description to reveal how the tool behaves under different conditions.
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 well-structured with clear sections (purpose, usage guidelines, args, routing logic, returns, examples) and every sentence adds value. At ~300 words, it's appropriately detailed for a complex tool with 9 parameters. Minor deduction because some sections could be slightly more concise (e.g., the 'WHEN TO USE' bullets have some 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?
For a complex tool with 9 parameters, 0% schema coverage, no annotations, but with an output schema, the description provides complete context. It covers purpose, usage guidelines, detailed parameter semantics, routing behavior, return format, and includes examples. The output schema handles return values, so the description appropriately focuses on usage and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Given 0% schema description coverage and 9 parameters, the description compensates fully by providing detailed semantics for each parameter. It explains how 'task' determines model tier with specific mappings, clarifies 'model' accepts both tier names and natural language descriptions, defines the purpose of 'language', 'context', 'symbols', 'include_references', and 'backend_type', and notes which parameters are required vs optional.
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's purpose: 'Execute a task on local/remote GPU with intelligent 3-tier model selection. Routes to optimal backend based on content size, task type, and GPU availability.' This specifies the verb (execute), resource (GPU), and key differentiators (3-tier model selection, backend routing) that distinguish it from sibling tools like 'think' or 'models'.
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 'WHEN TO USE' section provides explicit guidance with three bullet points covering local/private processing, specific task types (code review, generation, analysis), and general local hardware preference. This clearly tells the agent when to choose this tool over alternatives like 'think' (which might be for pure reasoning) or remote-only tools.
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:

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

Score Badge

Copy to your README.md:

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

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/zbrdc/delia'

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