mcp-ToseaAI

Official

by ToseaAI

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct action or resource (e.g., creating a parse vs. editing slides vs. exporting). Descriptions clearly differentiate similar-sounding tools like tosea_create_document_parse, tosea_parse_pdf, and tosea_pdf_to_presentation.
Naming Consistency5/5
All tools follow a consistent 'tosea_verb_noun' pattern using underscores and lowercase. The naming convention is uniform across the entire set, with only minor variations like 'pdf_to_presentation' which still adheres to the pattern.
Tool Count4/5
21 tools is slightly above the ideal 3-15 range, but each tool serves a specific purpose within the presentation lifecycle. The count is reasonable for the comprehensive functionality offered.
Completeness4/5
The toolset covers the full workflow from upload to export, including editing, template switching, and job polling. Minor gaps exist (e.g., no tool to delete a presentation or export), but core operations are well-covered.
Average 3.2/5 across 21 of 21 tools scored. Lowest: 2.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- Last stable release on March 23, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits, but it only states the basic action. It does not disclose pagination limits, whether it is read-only, or any side effects. The word 'list' implies read-only, but no confirmation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (one short sentence), but it sacrifices necessary details. True conciseness would preserve parameter context and usage instructions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has four parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain what the parameters do or what the response format is, making it hard for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no information about the four input parameters (page, per_page, status, search). Schema coverage is 0%, so the agent has no guidance on how to use them.
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 action (list) and the resource (current user's presentations). It is specific and unambiguous, but does not differentiate from sibling tools like tosea_get_presentation_full_data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor on the intended use of parameters (status, search). The description lacks any context for filtering or pagination behavior.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It reveals the output type (Markdown and image URLs) but omits behavioral details like whether files are kept, required permissions, rate limits, or side effects beyond creating a job.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (15 words, one sentence), but this comes at the cost of missing essential details. It is front-loaded but under-informative for a tool with 12 parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (12 parameters, no output schema, no annotations), the description is severely lacking. It does not explain the job lifecycle, return values, or how to use parameters, making it nearly unusable for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet the description does not explain any of the 12 parameters. It merely mentions 'upload local source files' without describing required file_paths or optional parameters like instruction, render_provider, or template_name.
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 it uploads local source files and creates a parse-only document job returning Markdown and image URLs. The verb 'upload' and 'create' specify the action and resource. It distinguishes from other parse-related siblings like tosea_parse_pdf by emphasizing the parse-only job nature, but could be more explicit about differences.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives such as tosea_parse_pdf or tosea_get_document_parse. No mention of prerequisites, context, or exclusions, leaving the AI to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions the tool is synchronous, but given no annotations, it fails to disclose other behavioral traits such as required permissions, effects of idempotency key, or what happens on conflict. For a mutation tool, transparency is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise but lacks structure. It could be improved by front-loading key info and separating purpose from contract details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no output schema, no annotations), the description is severely incomplete. It fails to explain what 'outline content' means in this context, how the 'action' parameter works, or what the 'aggregated MCP edit contract' entails.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and 7 parameters (4 required), the description adds no meaning beyond parameter names. It does not explain the 'instruction' field (expected to be a natural language command), 'model_name', or 'idempotency_key'. The tool's parameter semantics are entirely undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool modifies or inserts outline content synchronously, using a verb-resource pairing. It distinguishes somewhat from siblings like 'tosea_edit_slide_page' (which edits slide content) and 'tosea_generate_outline' (which generates a new outline), though the phrase 'aggregated MCP edit contract' is vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., 'tosea_edit_slide_page' for slide content editing, 'tosea_generate_outline' for generation). No prerequisites or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description lacks behavioral details such as destructive nature, rate limits, or prerequisites for screenshot_path.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences are concise but insufficient given the tool's complexity; essential details are missing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lacks explanations for critical parameters (action, edit_mode, model_name, etc.) and behavior; not complete enough for a 10-parameter tool without output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description adds no explanation for any of the 10 parameters, leaving the agent to infer from names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool modifies or inserts a slide, distinguishing it from other tools like tosea_edit_outline_page.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives; lacks context for choosing between modify/insert or edit_mode.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must cover behavioral traits. It implies a read-only list operation, but lacks details on output format, permissions, or whether listing is scoped to current user's visibility. Minimal transparency.
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?
Single-sentence description is concise and front-loaded. No wasted words, but could add more detail without harming brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple tool (one param, no output schema), the description is barely adequate. It does not describe return format, what 'user-visible' means, or how presentation_id relates to other tools. Lacks completeness for an agent to reliably invoke.
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?
Only parameter presentation_id has no description in schema (0% coverage). The description adds 'for a presentation' which weakly connects the parameter, but does not explain format or how to obtain the ID. Below baseline for low coverage.
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 action ('List') and the resource ('user-visible exported files for a presentation'). It distinguishes from sibling tosea_list_exports by specifying 'for a presentation', indicating filtering context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like tosea_list_exports or tosea_export_presentation. No when-not-to-use or context provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior but only states the purpose. It doesn't mention side effects (if any), authentication needs, or whether it refreshes the URL.
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 a single, concise sentence with no fluff. However, it is so brief that it sacrifices informativeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description should provide more context about return values, errors, or usage steps. It is insufficient for an agent to correctly invoke and handle the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description provides no explanation for any of the three parameters. The meaning of 'filename' and the role of 'export_type' are left entirely to the 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 action ('get a fresh download URL') and the target resource ('existing exported file'), distinguishing it from sibling tools like tosea_list_export_files or tosea_export_presentation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, nor any prerequisites like needing a prior export. The description lacks context on usage conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description uses 'Queue' which implies asynchronous processing but does not explain expected behavior, success/failure indicators, or how to retrieve results. With no annotations, the description fails to disclose any behavioral traits beyond basic action.
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 a single, efficient sentence with no unnecessary words. However, it could be expanded to include key details without sacrificing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has three parameters, no annotations, and no output schema. The description is too sparse to fully guide an agent; it lacks information on return values, error states, or job lifecycle. More detail is needed for adequate completeness.
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 does not clarify the meaning or allowed values of parameters like 'instruction' or 'render_provider'. The parameter names provide minimal clues, but the description adds no value beyond what is in the 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 'Queue outline generation for an existing presentation' clearly states the verb (queue generation), resource (outline), and scope (existing presentation). It distinguishes from sibling tools like tosea_edit_outline_page which edit an existing outline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as tosea_edit_outline_page or tosea_edit_slide_page. The description does not specify prerequisites or contextual triggers.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It reveals that the tool does not expose presentation details, but it does not state that the operation is read-only, idempotent, or specify error scenarios. For a status-checking tool, lacking clarity on side effects (likely none) and response structure (just status?) leaves gaps.
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?
A single sentence that is front-loaded and contains no filler. It is to the point, though it could be slightly improved by separating the action and the constraint for better readability. Minor loss due to vagueness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (1 param, no output schema, no annotations), the description is minimal. It lacks information on the returned status format, possible values, and how it relates to siblings like tosea_wait_for_job or tosea_get_document_parse_result. An agent needs more completeness to use it correctly alongside these tools.
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%, putting the burden on the description. The description does not explain the parameter 'document_parse_id' beyond implying it identifies a parse job. No constraints, format details, or examples are given. Since it's a single UUID, some clarity is inherent, but the description adds no value over the 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 action ('Fetch parse job status') and the resource ('for a document_parse_id'). It adds a distinguishing constraint ('without exposing presentation details') that differentiates it from sibling tools like tosea_get_document_parse_result. However, it could be more explicit that it returns status only, not the full parsed document.
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 for checking job status without presentation details, making it an alternative to tosea_get_document_parse_result. However, there is no explicit when-to-use, when-not-to-use, or direct reference to siblings. The agent must infer from context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions queuing, implying asynchronicity, but does not describe side effects (e.g., whether it modifies state), expected response (e.g., returns a job ID), or any safety considerations like rate limits or authentication.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, achieving conciseness but lacking structure. It could be more informative without becoming verbose, e.g., by listing parameter roles succinctly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It does not explain return value, parameter details, or behavioral context like asynchronicity or task status retrieval. Significant gaps remain.
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?
With 0% schema description coverage, the tool description must compensate. It only hints at the 'slides_to_generate' parameter via 'subset of slide numbers', but provides no meaning for other parameters like render_provider, render_model, image_model, or force. This omission hinders correct parameter usage.
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 verb (queue), resource (slides), and scope (all or subset). It distinguishes from sibling tools which handle different operations like document parsing, editing, exporting, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no mention of prerequisites or conditions for selecting subset vs all slides. The description is purely definitional with no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only states 'Fetch' implying read-only but does not mention authentication, rate limits, error handling, or whether the data is cached. Lacks detail beyond basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence efficiently conveys the tool's primary action and scope. No extraneous words or unnecessary 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?
Given the tool's simplicity (one parameter, no output schema), the description is minimally viable. It indicates what data is returned ('full structured... outlines and slides') but lacks details on output format, error cases, or prerequisites. The absence of annotations is not compensated.
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 input schema has one parameter (presentation_id, uuid) with 0% schema description coverage. The description does not explain the parameter at all, failing to compensate for the schema gap. The parameter's purpose is somewhat inferable from its name, but the description adds no value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Fetch' and resource 'full structured presentation data', clearly mentioning 'outlines and slides'. It distinguishes this tool from siblings like tosea_list_presentations (list only) and tosea_get_document_parse (different resource).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives such as tosea_list_presentations for summaries or tosea_edit_slide_page for editing. The description does not provide any context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only hints at constraints for template_file_id but does not disclose behavioral traits such as side effects, authorization needs, rate limits, or the meaning of 'parse-only stage'.
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 repetition. First sentence states main purpose, second provides parameter usage. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 12 parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain most parameters and does not describe return values or workflow integration.
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 should compensate. It explains logo_file_id and template_file_id but leaves 10 of 12 parameters (instruction, render_provider, etc.) completely undocumented. Only minimal value added.
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 action 'upload local source files and run the parse-only stage', specifying verb and resource. It implicitly distinguishes from sibling tools like tosea_pdf_to_presentation which do more than parsing.
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 gives some parameter usage guidance ('Use logo_file_id for...', 'Use template_file_id only with slide_mode="image"...'), but does not provide explicit when/when-not alternatives or context for selecting this tool over siblings like tosea_create_document_parse.
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, the description carries full burden. It accurately states the tool lists presentations with export history, implying a read-only operation. However, it does not mention whether the list is ordered, paginated, or if it counts items. The simplicity of zero parameters reduces need, but some additional context (e.g., 'returns presentation IDs') would improve transparency.
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 a single, clear phrase with no wasted words. It is front-loaded with the primary action. While it is concise, it could be structured as a full sentence for consistency, but it is not detrimental.
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 no parameters and no output schema, the description explains the basic behavior. However, it does not specify the format of the returned list (e.g., presentation names, IDs) or any ordering. For a simple list tool, this is minimally adequate but leaves some ambiguity about the output.
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 the schema description coverage is 100% (vacuously). The description does not need to add parameter information as there are none. According to guidelines, with 0 params, baseline is 4.
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 'List presentations that already have export history' clearly specifies the verb (list), resource (presentations), and filter (already have export history). It distinguishes from sibling 'tosea_list_presentations' which lists all presentations, and 'tosea_list_export_files' which lists export files themselves. However, it could explicitly mention the filtering aspect to enhance differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'tosea_list_presentations' or 'tosea_list_export_files'. There is no mention of prerequisites or context, leaving the agent to infer appropriate usage without explicit help.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It mentions 'exactly one template source' which implies mutual exclusivity but doesn't specify error behavior if multiple are provided. It does not state that the tool creates a new presentation (side effect), required permissions, or what the response contains.
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, well-structured sentence that immediately states the tool's purpose. It is concise (20 words) with no fluff, and front-loads the key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters, no output schema, and no annotations, the description should provide more context. It lacks details about the purpose of render_model and logo_file_id, whether the new presentation is a copy, and what the tool returns. The description is too sparse for a tool of this complexity.
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 explains three parameters (template_name, user_template_id, system_template_key) and implicitly presentation_id, but two parameters (render_model, logo_file_id) are left unexplained. The description adds meaning to half the parameters, insufficient for full 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 the action: 'Fork an existing presentation into a new presentation using exactly one template source.' It specifies the resource (existing presentation) and the three mutually exclusive template parameters, distinguishing it from sibling tools like tosea_edit_slide_page or tosea_export_presentation.
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 when to use the tool (forking with a template) but does not provide explicit guidance on when not to use it or mention alternatives. It lacks context like 'use this when you need to create a new presentation based on an existing one with a different template, rather than editing in place.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description clearly states the polling behavior and terminal conditions. However, it does not describe backoff mechanism, rate limiting, or blocking nature, which are partially inferable from schema parameters.
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, well-structured sentence that is front-loaded with the key action. No extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description lacks details on return value, error states, or timeout handling. For a complex polling tool with multiple parameters and no output schema, more context is needed for correct agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no information about parameters beyond the input schema names. Given 0% schema coverage, it fails to explain parameter purpose, valid values, or behavior.
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 polls a document parse job until it reaches a terminal state (completed, failed, or cancelled). It distinguishes from siblings like tosea_get_document_parse (single check) and tosea_create_document_parse (initiation).
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 after creating a parse job, but does not provide explicit when-to-use or when-not-to-use guidance. It lacks mention of alternatives like synchronous wait or single status check.
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?
No annotations are provided, so the description must fully convey behavioral traits. It discloses the polling loop termination conditions (completed, failed, cancelled) and a specific nested status case. However, it does not address timeout behavior, error handling, or whether it makes multiple requests, leaving gaps in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences. The first sentence states the primary function, and the second adds an important conditional nuance. No extraneous information, perfectly front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of output schema and annotations, the description lacks information about return values, possible statuses, error notifications, or how to interpret the poll result. For a polling tool, output details are essential for integration, but they are completely omitted.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description adds no meaning to the four parameters (presentation_id, timeout_seconds, poll_interval_seconds, max_poll_interval_seconds). It does not explain their purpose, defaults, or constraints, which are critical for correct usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it polls a presentation job until completion, failure, or cancellation. It also provides a specific nuance about nested job status, which distinguishes it from sibling polling tools like tosea_wait_for_document_parse.
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 concrete usage note about when to wait on data.job.status instead of top-level status, adding context for correct usage. However, it lacks explicit guidance on when not to use this tool or alternatives beyond the sibling tools.
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?
No annotations exist, so the description must provide behavioral context. It reveals the output contents (Markdown, payloads, image URLs) and the condition of a completed job, but does not mention error handling, what happens if the job is not completed, or side effects (e.g., read-only nature).
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 of 17 words, front-loading the core action and outputs. No extraneous information; every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description covers the basic 'what' but lacks lifecycle context: it assumes the user knows to first create a document parse job, check status, and wait. The presence of sibling tools mitigates this slightly, but the description itself misses preconditions and error states.
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?
With 0% schema description coverage, the description must compensate for parameter meaning. It only names the parameter 'document_parse_id' without explaining its origin or relation to other tools (e.g., it comes from tosea_create_document_parse). The UUID format is noted but not elaborated.
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 verb 'Fetch' and the specific resources: 'final Markdown, per-file parse payloads, and extracted image URLs'. It uniquely identifies the tool's role among siblings like tosea_get_document_parse and tosea_wait_for_document_parse, which handle status and waiting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for completed jobs via the word 'completed', but does not explicitly state when to use this tool versus alternatives like tosea_get_document_parse (which likely provides status) or prerequisites like creating a parse first. No exclusion guidance is 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?
No annotations are provided, so the description bears the full burden. It explains parameter dependencies and constraints but does not disclose error handling, idempotency behavior (despite containing an idempotency_key parameter), rate limits, or potential destructive actions. The tool likely creates files but not explicitly stated as non-destructive.
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 a single paragraph that front-loads the main purpose and provides key usage notes. It is moderately concise but includes a redundant opening phrase. Every sentence adds value, though some could be merged for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 14 parameters, 0% schema description coverage, and no output schema, the description is incomplete. It fails to explain critical inputs like file_paths, instruction, export_filename, and many rendering options. The tool's complexity demands more comprehensive documentation.
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?
With 0% schema description coverage, the description must compensate. It explains 4 parameters (slide_mode, template_file_id, logo_file_id, output_format) but leaves 10 parameters unexplained (file_paths, instruction, export_filename, render_provider, render_model, image_model, slide_domain, page_count_range, template_name, idempotency_key). This is a significant 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 clearly states the tool's function: 'Upload local source files and generate a final export in one shot.' This distinguishes it from sibling tools like tosea_parse_pdf or tosea_export_presentation, which are single-step operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance for parameter usage: defaults for slide_mode, when to use slide_mode='image', constraints on template_file_id and logo_file_id, and advice for output_format='pptx_image'. However, it does not explicitly compare to sibling tools for when to use this one-shot approach versus composing manual steps.
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?
No annotations are provided, so the description must carry the burden. It states it queues a job (implying asynchronous behavior), but does not mention that the presentation must be in a 'completed' state, permission requirements, or what happens on failure. Minimal behavioral context for a mutation tool.
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 purpose, followed by focused usage guidance. No extraneous information, every sentence adds value.
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 covers the main action and required parameters partially, but omits details on optional parameters and the asynchronous nature (e.g., returning a job ID for use with tosea_wait_for_job). Given the complexity of 4 parameters and no output schema, more completeness 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 coverage is 0%, so the description should compensate. It adds meaning to 'output_format' by explaining when to use specific enum values, and implicitly covers 'presentation_id'. However, it does not explain 'export_filename' or 'idempotency_key', leaving two parameters undocumented.
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 'Queue an export job for a completed presentation', specifying the action (queue export) and resource (completed presentation). It distinguishes from sibling tools like tosea_list_exports and tosea_redownload_export, which deal with listing or re-downloading exports.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use specific output formats ('Use output_format='pptx_image' when...', 'Use html_zip only for...'). However, it does not explicitly contrast with alternative tools (e.g., use tosea_list_exports to check status), leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states 'Inspect quota status', which implies read-only but does not explicitly confirm safety, auth requirements, or any side effects. The description is minimal in behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words. It is front-loaded and directly conveys the core function. Every word contributes to meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple status inspection tool with one optional parameter and no output schema, the description is adequate but minimal. It could be improved by noting what the response contains (e.g., quota usage and limits) or clarifying that no modification occurs.
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 single optional parameter `feature_key` has no schema description, but the tool description explains its semantics: if provided, inspect quota for that feature; if omitted, inspect all features. This adds necessary meaning beyond the schema structure.
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 inspects quota status, with the ability to target all features or a single feature key. This verb-resource combination is distinct from sibling tools, none of which deal with quota status.
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 implies usage context: provide a feature_key for a single feature or omit for all. While no explicit alternatives or exclusions are given, the lack of competing quota tools makes this sufficient. Clear context is provided.
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?
No annotations provided, but the description accurately characterizes it as a read-only connectivity check with no side effects; lacks details on error behavior but adequate for a simple health check.
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 sentence with no unnecessary words, perfectly concise and 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 health check tool with no parameters or output schema, the description provides complete context—its purpose and scope are fully covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so the description does not need to add parameter details; baseline 4 applies as schema coverage is 100%.
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 verb 'check' and the resource 'MCP connectivity to ToseaAI', distinguishing it from sibling tools that handle document creation, editing, and exports.
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?
No explicit guidance on when to use this tool versus alternatives; usage is implied as a connectivity check but not elaborated (e.g., before other operations).
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 uses 'Inspect' which implies a read-only, non-destructive operation. Without annotations, this is sufficient to convey that no changes are made. More detail on output format could be given, but the behavioral intent is clear.
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, concise sentence that is front-loaded with the key action and resource, earning its place with no wasted words.
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 simplicity (zero parameters, no output schema), the description adequately covers what it does and when to use it. It could mention the return value format, but for a pre-check tool, the current description is sufficient.
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 no parameters, and the description does not need to add param info. Baseline 4 applies as the description correctly focuses on the tool's purpose without needing parameter details.
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 verb 'Inspect' and the resource 'current account tier and feature access', making the tool's purpose evident. It distinguishes from siblings by focusing on permissions summary, which is unique among the listed 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 says 'before expensive runs', providing clear context for when to use the tool. It does not explicitly mention when not to use or alternatives, but the single use case is well-defined.
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:

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

Score Badge

Copy to your README.md:

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

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/ToseaAI/mcp-ToseaAI'

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