intervals-icu-mcp

by hadidwirsty

Overview Schema Related Servers Score Discussions

TypeScript

Local

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 resource and action. Activity-related tools are separated by data granularity (list, details, intervals, streams, messages), and event/custom item tools follow clear CRUD patterns. No two tools appear to serve the same purpose.
Naming Consistency5/5
All tools use a consistent verb_noun pattern in snake_case. Retrieval uses get_, creation uses add_/create_, updates use update_/add_or_update_, and deletion uses delete_. Minor variation like add_or_update_ is predictable.
Tool Count4/5
At 19 tools, this is above the ideal 3-15 range but appropriate for the broad scope covering activities, events, wellness, gear, power curves, and custom items. The tools are grouped by domain and each is justified; still, a few could be consolidated, so not a perfect 5.
Completeness4/5
Core workflows are well covered: activities have read and message addition, events have full CRUD, and custom items have full CRUD. Gaps include no activity update/delete, no gear management, and no wellness update, but these may be outside the API's intended scope or rare needs.
Average 3.5/5 across 19 of 19 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 30 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention that deletion is permanent, irreversible, or that it requires any specific permissions. For a destructive operation, this is a significant gap.
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 concise sentence, but it is under-specified rather than appropriately concise. It states the basic action but omits important details that would make it more useful, such as permanence or failure behavior. It is not overly wordy, but it is too brief.
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 lack of annotations and output schema, the description should do more to explain the tool's behavior. For a delete tool, it should at least note that the deletion is permanent and perhaps mention required authentication. The current description is minimal and leaves the agent without enough context for a destructive operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage for all three parameters, so the description doesn't need to explain them. The description only mentions 'ID', which aligns with the itemId parameter, but adds no additional meaning beyond what the schema already documents.
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 'Hapus satu custom item berdasarkan ID' clearly states the action (delete) and the resource (custom item) with the key parameter (ID). It distinguishes itself from sibling tools like create_custom_item and update_custom_item by using the verb 'Hapus' (delete), but it doesn't add explicit scope or context beyond the title.
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 when you want to delete a custom item, but it provides no explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The context is clear enough for a straightforward delete operation, but there is no extra guidance.
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 present, so the description carries the full burden of behavioral disclosure. It only says 'get complete details' without mentioning return format, error handling, authorization requirements, or any side effects. The read-only nature is implied by 'get' but not elaborated, and no additional behavioral context is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that directly states the tool's function with no redundant words. It is appropriately concise for a simple getter tool, even if it lacks contextual depth.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is minimally viable for a simple read tool, but it lacks important contextual details such as what 'complete details' includes, whether it returns the full activity object, or any limitations. With no output schema, the description should have provided more clarity about the return value. This falls short of a 4 but is not as severe as a 2 given the straightforward nature of the operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters (apiKey and activityId) already explained in the schema. The description adds no parameter information, but the baseline of 3 applies because the schema fully documents the parameters.
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 verb (get), resource (activity details), and scope (one activity by ID). It implies a distinction from sibling tools like get_activity_intervals or get_activity_streams by saying 'detail lengkap' (complete details), but it does not explicitly name alternatives or contrast with them.
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 get_activities or get_activity_streams. The description only states what the tool does, without any context about appropriate use cases, prerequisites, or exclusions.
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 available, the description must carry the burden of behavioral disclosure. It only restates the tool's purpose and does not mention return format, ordering, permissions, pagination, or any side effects. For a read operation, this is minimal but leaves significant gaps.
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 and contains zero wasted words. It efficiently communicates the tool's core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (2 parameters, no output schema), but the description omits any detail about what the response looks like (e.g., list of messages, count, or message object structure). Given the simplicity and lack of annotations, this is adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both apiKey and activityId already explained in the schema. The description adds no additional meaning or context about parameter usage, so a baseline of 3 is appropriate.
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 'Ambil catatan/komentar (messages) pada satu aktivitas' clearly states the tool fetches notes/comments for a specific activity, using a specific verb and resource. It is distinct from sibling tools like get_activity_details and add_activity_message, though it does not explicitly name alternatives for 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?
The description provides no guidance on when to use this tool versus alternatives such as add_activity_message or get_activity_details. No context, prerequisites, or exclusions are mentioned beyond the basic purpose.
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 provided, the description carries the full burden of behavioral disclosure. It states 'delete' but does not explicitly disclose that the action is permanent, irreversible, or may require specific permissions, adding no context beyond the tool's name.
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 one short sentence with no filler, perfectly concise and front-loaded for a simple delete operation.
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 essential context for a destructive operation, such as permanence, authorization requirements, and any prerequisites. The schema covers parameters, but the description fails to provide sufficient operational context for an agent to safely invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is set to 3. The description highlights the eventId parameter but adds no additional meaning beyond the schema's existing 'Event ID Intervals.icu' description.
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 deletes one calendar event based on its ID, using a specific verb and resource. It inherently distinguishes from sibling read tools like get_events and get_event_by_id.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. There is no mention of prerequisites, such as first retrieving the event with get_event_by_id, or any caution that deletion is irreversible.
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 the full burden of behavioral disclosure. It states it retrieves a list, which implies a read operation, but does not mention authentication requirements (e.g., apiKey), default date ranges, pagination, or whether the response includes full activity data or just summaries. It adds little beyond what the schema already provides.
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, focused sentence that immediately states the purpose. There is no wasted text, and it is appropriately 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 an output schema and annotations, the description must provide context about return values and tool behavior. It only says 'list of activities' without indicating the fields, default limits, or whether it returns full details or just identifiers. This could lead to incorrect tool selection, especially with sibling tools like get_activity_details available.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already well documented. The description's mention of 'date range' aligns with startDate and endDate but does not add new meaning to limit, apiKey, or athleteId. It meets the baseline but does not elevate parameter understanding beyond 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 tool's function: 'Ambil daftar aktivitas latihan seorang athlete dari Intervals.icu dalam rentang tanggal tertentu' (Get a list of an athlete's training activities from Intervals.icu within a date range). It specifies the verb (get), the resource (list of activities), and the scope (date range), distinguishing it from sibling tools like get_activity_details or get_activity_streams.
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 explicit guidance on when to use this tool versus alternatives. It does not mention that get_activity_details is for individual activity details or that filtering is limited to date range. The usage is only implied by the purpose, not stated.
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 the full burden. It only states that it retrieves details, without disclosing behaviors such as read-only confirmation, error handling (e.g., 404 if not found), or the shape of the returned object. The description adds nothing beyond the basic function.
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 with no filler. It front-loads the core function and is easily scannable.
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?
There is no output schema or annotations to supplement the description. The description does not specify what 'detail' includes, what the return format is, or any error conditions. While the tool is simple, this leaves gaps for an agent trying to predict the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not mention any parameters. However, the schema provides descriptions for all three parameters (apiKey, eventId, athleteId) with 100% coverage, so the baseline score of 3 applies.
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 'Ambil detail satu event kalender berdasarkan event ID' (Get details of one calendar event by event ID), which specifies the verb, resource, and scope. It clearly distinguishes from get_events by emphasizing 'satu event' (one event), though it does not explicitly reference sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives. The only implied usage is that it requires an event ID, which is evident from the input schema and the phrase 'berdasarkan event ID'.
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 should disclose behavioral traits. It mentions returning gear with basic statistics, but does not explicitly state read-only nature, error cases, pagination, or permission requirements, leaving the agent with incomplete information.
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, front-loaded with the action and resource, and contains no redundant words. It is concise and structurally clear.
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 low complexity (2 optional parameters, no output schema), the description is adequate but minimal. It covers the core function but omits usage context, return format details, or any potential limitations, making it merely sufficient rather than comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides full descriptions for both parameters (apiKey, athleteId) with 100% coverage. The tool description adds no additional parameter meaning, so the baseline score of 3 applies.
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 retrieves a gear catalog with basic statistics for an athlete, using the specific verb 'Ambil' (get) and resource examples like 'sepeda, sepatu' (bikes, shoes). This distinguishes it from sibling tools like get_activities or get_custom_items, which target different 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?
There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The description only states what the tool does, not when to choose it over siblings.
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 bears the full burden of behavioral disclosure. It only states that the tool adds a note/comment, but does not mention authentication requirements, whether the activity must already exist, idempotency, return behavior, or side effects. For a mutation tool, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the action verb and resource. No unnecessary words or repetition; every word contributes to understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple and the schema fully documents parameters, so the description meets the minimum for invocation. However, the lack of annotations, output schema, and behavioral context (e.g., expected response or error handling) leaves notable gaps in the overall context.
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 100%, with each parameter having a description. The tool description adds minimal semantic value beyond the word 'comment' for content, but the schema already provides sufficient information for parameter meaning.
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 ('Tambahkan' = add) and identifies the resource ('catatan/komentar baru ke sebuah aktivitas' = new note/comment to an activity). This clearly differentiates it from sibling read tools like get_activity_messages and from the more general add_or_update_note.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case: adding a new message/comment to a specific activity. However, it provides no explicit exclusions, alternatives, or context on when this tool should be preferred over add_or_update_note or other activity-related tools. Usage is implied rather than guided.
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 provided, the description carries the full burden. It discloses the mutation action (create/update) and the note type, but does not mention permissions, what happens to existing notes, response format, or other side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence in Indonesian, front-loading the action and adding the category context. It contains no filler or redundancy, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple and the schema covers all parameters. However, the description does not explain the create-vs-update behavior triggered by eventId, nor does it mention authentication or output; given the lack of annotations, a bit more context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with detailed descriptions for all 7 parameters, including defaults and field-specific purposes. The description adds no additional parameter information, which is acceptable given the schema's completeness.
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 verb 'create or update', the resource 'plain text note (category NOTE)', and the scope 'in the Intervals.icu calendar'. This differentiates it from sibling tools for workouts, custom items, and events.
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 context is implied: this tool handles plain-text notes in the calendar, as opposed to workouts/custom items/events. However, the description does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or specific use cases.
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 on its own. It only states that the tool retrieves time-series data, which is evident from the verb, but does not address authentication, rate limits, pagination, units, or potential errors. Minimal additional transparency beyond the 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?
The description is a single, concise sentence that front-loads the main action and resource. Every word carries meaning, with no unnecessary filler. Well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no annotations, no output schema, and moderate complexity. The description provides a clear purpose and examples, but it lacks information about return format, how streamTypes affects output, or differentiation from sibling tools. It is adequate for a simple getter but leaves gaps that would benefit from expansion.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers all parameters with 100% coverage, so a baseline of 3 is appropriate. The description adds marginal value by listing example stream types, but this is not essential since the streamTypes parameter description already provides examples. No significant new meaning is 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 a specific verb ('Ambil' = retrieve) and resource (time-series streams from a single activity). The examples (power, heart rate, cadence, altitude, distance, velocity) further clarify the scope, effectively distinguishing it from siblings like get_activity_details or get_activity_intervals.
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 when you need stream data for a specific activity, but it does not explicitly mention when to use this tool over alternatives or provide any exclusion criteria. The guidance is purely implicit from the provided examples and tool name.
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 only states that it retrieves details; it does not mention return format, error handling, permission requirements, or any side effects. For a read operation, this is insufficient beyond the most 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence that conveys the essential purpose without redundancy. It earns its place and is immediately readable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a simple getter, and the schema thoroughly documents parameters. However, there is no output schema and the description does not explain what the returned custom item contains or how errors are handled. It is minimally adequate but could be improved with a note on response structure or not-found behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with itemId described as 'ID custom item', apiKey and athleteId also documented. The description adds no additional parameter context beyond what the schema already provides, matching the baseline for full schema 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 'Ambil detail satu custom item berdasarkan ID' clearly states the action (ambil/get), resource (custom item), and scope (satu/one by ID). It distinguishes from the sibling get_custom_items list tool by emphasizing single-item retrieval.
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 phrase 'berdasarkan ID' implies the tool should be used when an item ID is known, but it does not explicitly mention when to prefer this over get_custom_items or exclude other alternatives. Sibling names provide context but no direct guidance.
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 the full burden of disclosing behavioral traits. However, it only states the action 'get list' without explicitly confirming it is a read-only operation, mentioning any side effects, or describing limitations. The word 'get' implies retrieval but does not ensure 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 a single sentence that is concise and front-loaded with the primary action. It contains no redundant information and effectively communicates the tool's purpose.
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, the description is adequate but could be more complete. It does not explicitly state that this retrieves all custom items for an athlete (not just one), nor does it clarify the output format, which is especially relevant since there is no output schema. The presence of sibling tools also calls for a clearer distinction.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage for both parameters (apiKey, athleteId) with clear descriptions, so the schema already handles parameter semantics. The description itself does not add any additional parameter context, but the baseline of 3 applies given the high schema 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 uses a specific verb 'Ambil daftar' (get list) and clearly identifies the resource as 'custom item' with examples (chart, field, zones). This distinguishes it from siblings like get_custom_item_by_id, which retrieves a single item.
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 context that the tool returns custom items belonging to an athlete, but it does not explicitly state when to use this tool versus alternatives such as get_custom_item_by_id, create_custom_item, or update_custom_item. Usage is implied but not clearly differentiated.
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 carry the full burden of behavioral disclosure. It does disclose the kind of data returned (HRV, sleep, etc.) and the date-range scope, but it omits important behavioral traits such as pagination, timezone handling, response structure, or authentication requirements (only the schema hints at apiKey). This is insufficient for a tool with zero annotation support.
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, tight sentence in Indonesian, front-loaded with the main purpose ('Ambil data wellness harian athlete') followed by a parenthetical list of data types and the date-range qualifier. Every word earns its place; no fluff or repetition.
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 has no annotations and no output schema, the description does a reasonable job explaining the content and scope. It lists the data categories and date range, which is enough for basic understanding. However, it lacks details on response format, defaults (though the schema provides defaults), or any caveats about data completeness, making it minimally adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with each parameter (apiKey, endDate, athleteId, startDate) having a meaningful description. The description adds little beyond the schema—it merely mentions 'dalam rentang tanggal tertentu' which aligns with startDate/endDate. Per the rubric, baseline is 3 because the schema handles the heavy lifting.
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: 'Ambil data wellness harian athlete' (get daily wellness data for athlete) and enumerates specific data types (training metrics, HRV, resting HR, sleep, subjective scores). This specific verb+resource combination distinguishes it from sibling tools like get_activities or get_activity_details.
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 retrieving wellness data over a date range, and it lists typical wellness metrics. However, it does not explicitly mention when to prefer this over sibling tools or provide exclusions (e.g., 'use get_activities for workout logs'). The context is clear but lacks explicit guidance.
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 carry the full burden of behavioral disclosure. It does not state that this is a mutation that creates persistent state, whether any permissions are required, or how errors are handled. The only extra info is the enum note, which is parameter semantics, not behavior. This is a significant gap for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences. The first states the purpose, and the second delivers the most important caveat about enum values. Every sentence earns its place, and the critical note is front-loaded for discoverability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 7 parameters, 2 required, and a complex nested `content` object with no output schema. The description addresses only one case (INPUT_FIELD/ACTIVITY_FIELD) and leaves content requirements for other item types unspecified. It also lacks guidance on usage and return values. While sufficient for a narrow use case, it is incomplete for the full range of item types.
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 100% coverage with descriptions for all properties, so the baseline is 3. However, the description adds critical clarifications for the nested `content` object, specifying valid enum values for `type` ('numeric' | 'text' | 'select') and `aggregate` (MIN|SUM|MAX|AVERAGE) that are not present in the schema. This genuinely goes beyond the schema's generic 'object' description, adding meaningful parameter insight.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Buat custom item baru' (Create a new custom item), which is a specific verb + resource. The parenthetical '(chart/field/zones)' clarifies the scope of item types. This clearly distinguishes it from sibling tools like update_custom_item, delete_custom_item, and get_custom_items.
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 its verb ('Buat' = create), but it does not explicitly state when to use this tool over alternatives, mention any prerequisites, or provide exclusions. There is no reference to update/delete tools or conditions under which creation might be inappropriate. This is implied usage at best.
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 the full burden of behavioral disclosure. It mentions the data fields returned but does not state that the operation is read-only, any permission requirements, or potential limitations such as pagination or availability. For a data retrieval tool, this lack of explicit safety or behavioral context is a notable gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded with the main action and details. Every word contributes to conveying the tool's core function without redundancy.
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?
While the description explains what data is retrieved, it lacks an output schema and does not describe the response structure, possible formats, or any additional context like ordering or grouping of intervals. For a simple tool this is adequate, but there are clear gaps in what an agent might need to know.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both apiKey and activityId having descriptions. The tool description adds no extra parameter meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: retrieving interval/lap data (power, HR, pace per segment) from a single activity. It uses a specific verb ('Ambil' / retrieve) and a specific resource, distinguishing it from sibling tools like get_activity_streams or get_activity_details.
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 by specifying 'dari satu aktivitas' (from one activity), indicating it is for a single activity rather than bulk operations. However, it does not explicitly name alternative tools or provide exclusions, so it stops short of a full 5.
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 provided, the description carries the full burden for behavioral disclosure. It explains the transaction semantics (create/update based on eventId) and mentions workoutDoc for steps, but does not disclose side effects, required permissions, potential overwriting behavior, or the response format. For a mutation tool with no annotations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core purpose. It uses only two sentences to convey the resource, the create/update mechanism, and the optional workoutDoc structure. There is no wasted wording or repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (9 params, nested objects, no output schema, no annotations), the description provides a solid overview but lacks some completeness. It does not mention the required parameters (name, workoutType) or what the response looks like. It also does not advise how to obtain an event_id (e.g., via get_events). A more complete description would address these gaps, especially since there is no output schema to fall back on.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by clarifying eventId's behavior ('Kirim event_id untuk update, kosongkan untuk membuat baru') and by elaborating on workoutDoc's purpose (defining steps with warmup/interval/cooldown, target power/hr/pace). This enhances the parameter meaning beyond the raw schema definitions.
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: 'Buat atau update planned workout (event kalender kategori WORKOUT) di Intervals.icu.' It specifies the resource (planned workouts, calendar event category WORKOUT) and distinguishes it from siblings like add_or_update_note and delete_event. The verb 'Buat atau update' is specific and action-oriented.
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 explicit guidance on when to create vs update: 'Kirim event_id untuk update, kosongkan untuk membuat baru.' This clarifies the key decision point for using the tool. It does not explicitly name alternatives or exclusions, but the create/update distinction is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the transparency burden. It clarifies that the output is power per duration in watts and mentions the seasonal/custom scope, but it does not disclose response format, defaults (though defaults are in schema), any read-only guarantee, or interaction between season flags and custom dates. It is adequately descriptive but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that packs the essential purpose and scope options without wasted words. Every clause contributes to understanding what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 9 optional parameters and no output schema, so the description should clarify return values and parameter interactions. It explains the core output concept but does not specify the response structure or how custom dates combine with season flags. This is adequate but leaves some ambiguity.
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 100%, so parameter meanings are fully documented in the schema. The description adds no additional parameter-level detail beyond what the schema already explains. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's function: retrieving power curves (best power per duration) for an athlete, with scope options for current/last season or custom date ranges. It uses a specific verb (Ambil/get) and resource (power curves), which distinguishes it from sibling tools focused on activities or streams.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use this when you need an athlete's power curve for a season or custom date range. It does not explicitly mention alternatives or exclusions, but the focus is unambiguous. Lacks a 'when not to use' or alternative tool reference.
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 carries the full burden of behavioral disclosure. It discloses that the tool returns a list of event types within a date range, but does not state read-only behavior, response structure, pagination, or error conditions. This is basic but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the action, and includes the key event types without any redundancy or filler. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with optional parameters and no output schema, the description adequately defines the tool's scope and purpose. It would benefit from explicit mention of read-only behavior, but given the simplicity, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with detailed descriptions for all four parameters (apiKey override, endDate default, athleteId default, startDate default). The description only mentions the date range, adding no additional meaning beyond the schema. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Ambil daftar' (get list) with a clear resource 'event kalender' (calendar events) and scope 'rentang tanggal' (date range). It enumerates event types (planned workout, race, note), which distinguishes it from siblings like get_event_by_id (singular) and get_activities (activities, not events).
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 states a clear use case (list calendar events within a date range) and implies this is for listing multiple events, contrasting with get_event_by_id for single events. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and discloses the important behavior that only explicitly provided fields are updated, preventing accidental clearing of unspecified fields. It does not cover error cases or response format, but the core partial-update behavior is a valuable 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, front-loaded with the purpose, and contains no filler. It efficiently communicates both the action and the key updating behavior.
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 an 8-parameter tool with nested objects and no output schema, the description is quite brief. It explains the core update mechanism but omits information about return values, update confirmation, or error handling. The schema covers parameters well, but the description leaves the response behavior unspecified, which is a gap given the tool's complexity.
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 covers 100% of parameters with individual descriptions, so the baseline is 3. The description adds cross-parameter semantics by explaining that only filled fields will be sent, which clarifies the effect of omitting any optional parameter—something the schema does not state.
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 specifies the action (update) and the resource (custom item), and explicitly notes the item must already exist. This distinguishes it from sibling tools like create_custom_item and delete_custom_item.
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 for updating existing custom items and provides the key guidance that only filled fields are sent, which informs the agent which parameters to include. It does not explicitly mention alternatives or exclusions, but the 'sudah ada' (already exists) clarifies that creation is out of scope.
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:

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

Score Badge

Copy to your README.md:

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

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/hadidwirsty/intervals-icu-mcp'

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