TimeBase MCP

Official

by epam

Overview Schema Related Servers Score Discussions

Python

Hybrid

Server Quality Checklist

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

Latest release: v0.2.2
Disambiguation4/5
Tools are mostly distinct, targeting either streams (schema, time range, symbols, spaces, messages) or server state (activity, status, configuration). The only slight overlap is among list_timebase_instances, get_server_configuration, and get_timebase_status, but descriptions clarify their different focuses. Overall, an agent can reliably select the right tool.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern with lowercase snake_case (e.g., list_streams, get_stream_schema). The prefix verbs are consistently list_ or get_, with execute_query and compile_query following the same style. No mixed conventions or inconsistent naming.
Tool Count5/5
With 15 tools, the set is well-scoped for the domain of TimeBase monitoring, metadata inspection, and querying. Each tool addresses a specific aspect without redundancy, and the size is within the optimal range.
Completeness4/5
The surface covers core read-side operations: stream enumeration, schema and time range retrieval, message sampling, QQL query execution, and activity monitoring. Missing write operations are likely intentional for a read-oriented server, though there is no direct tool to fetch a specific message by timestamp or offset (must use execute_query). This is a minor gap, so the completeness is strong.
Average 3.8/5 across 15 of 15 tools scored. Lowest: 3.1/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 46 commits in the last 12 weeks
- Last stable release on August 5, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under Apache 2.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description contributes no behavioral information beyond what the annotations already declare (e.g., destructiveHint=true). It does not disclose side effects, execution semantics, or any constraints beyond the schema, making it a bare restatement of the title.
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, direct sentence with no wasted words. It is appropriately front-loaded and instantly understandable, though minimal.
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 benefits from a full input schema, output schema, and annotations, which cover many gaps. However, the description does not mention usage context or distinguish this from sibling tools like compile_query, leaving a moderate completeness gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides clear descriptions for all three parameters (query, limit, instance_key), achieving 100% coverage. Since the schema does the heavy lifting, the description adds no further parameter semantics, warranting the baseline score.
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 ('Execute') and resource ('a TimeBase QQL query'), making the tool's purpose evident. However, it does not differentiate from sibling tools like compile_query, which is a similar but distinct operation.
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 compile_query or get_stream_messages. There are no stated prerequisites, exclusions, or context suggesting the appropriate use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, but the description adds no additional behavioral context. It does not mention pagination, performance, or any special constraints, which is a gap given the tool has a cursor/limit pagination pattern.
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 verb and resource, with zero wasted words. It is appropriately concise for the information it conveys.
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 rich input schema (all parameters described), output schema, and annotations indicating read-only safety, the description is mostly complete for operational use. The only missing element is explicit usage guidance, which is already penalized in the usage_guidelines dimension.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% parameter description coverage, so the baseline is 3. The description's mention of 'specific stream' aligns with the stream_key parameter but adds no meaning beyond what the schema already provides for limit, cursor, or instance_key.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets symbols for a specific stream, using the verb 'Get' and identifying the resource as 'symbols of a specific stream'. It distinguishes from sibling tools like get_stream_schema or get_stream_messages, but does not explicitly mention scope or filtering.
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, and no mention of prerequisites or exclusions. It simply states a fact, leaving the agent to infer usage from the name and parameters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and openWorldHint=true, indicating a safe read operation. The description adds the behavioral detail that the time range is in UTC, which is useful. However, it does not disclose behavior for missing streams or provide details about output format beyond what the output schema already covers.
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 words. It front-loads the core action and result, making it easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with a well-described schema and an output schema present, the description is adequately complete. It covers the key behavioral nuance (UTC timezone) and the tool's scope (specific stream). The only minor gap is the lack of explicit differentiation from similar sibling tools, but this is not critical given the overall simplicity.
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 clear descriptions for stream_key ('Stream key to inspect') and instance_key ('TB instance key. Required when multiple TimeBase instances are configured.'). The description adds no extra parameter meaning beyond what the schema already provides, so a baseline score 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 'Get the time range of a specific stream in UTC' clearly identifies the verb (get), resource (stream), and result (time range in UTC). It distinguishes itself from the sibling 'get_stream_space_time_range' by specifying 'specific stream' rather than 'stream space', though it does not explicitly name the alternative.
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 like get_stream_space_time_range, nor does it mention prerequisites or exclusions. The only context is the short descriptive sentence, leaving the agent to infer usage from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, covering the read-only nature. The description adds no extra behavioral context (e.g., return format details, errors), but it does not contradict the annotations either.
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 that conveys the essential purpose without any fluff. Perfectly concise for a simple read-only retrieval tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (2 params, no nesting) and comes with a clear output schema and parameter descriptions. The description is sufficient to understand the tool's role, though it could briefly hint at the instance_key dependency for multi-instance setups, but the schema already covers that.
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 'Stream key to inspect' and 'TB instance key. Required when multiple TimeBase instances are configured.' providing adequate parameter meaning. The description text itself adds no additional parameter insight, so the baseline 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's action ('Get') and resource ('schema of a specific stream'), making it easy to distinguish from sibling get_stream_* tools that retrieve time ranges, symbols, or messages.
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. It does not mention prerequisites like needing a stream_key, nor does it explain when instance_key is required, despite the sibling context showing many similar get_stream_* 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?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds the detail that the time range is in UTC, which is useful but not a behavioral trait. There is no contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the key action and resource. It contains no filler words and 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?
Given the rich schema (100% parameter coverage), annotations, and presence of an output schema, the description provides adequate context for a read-only getter. The UTC detail is valuable, but the lack of explicit differentiation from similar sibling tools slightly reduces completeness.
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 fully documented in the schema. The description adds no extra meaning beyond the schema, and the baseline score of 3 is appropriate since the schema carries the burden.
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 'Get' with the resource 'time range of a specific stream space' and specifies UTC, clearly distinguishing it from the sibling get_stream_time_range which likely targets the whole stream rather than a space. It is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention get_stream_time_range or other related tools, nor does it state any exclusions or prerequisites. The context of 'stream space' is implied by the name but not explicitly explained.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the description carries a lower burden. It adds the useful detail that messages can be retrieved from the beginning or end of the stream ('first or last N'). However, it does not describe ordering guarantees, pagination, performance characteristics, or any other behavioral traits beyond what the schema and annotations already convey.
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 core action and resource. It contains no filler, repeated information, or unnecessary context, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with a full output schema and annotations, the description covers the essential functionality. It specifies the main behavioral variant (first vs. last N) but does not elaborate on return value structure or edge cases; however, the output schema handles return details. The description is adequate given the annotations and schema richness.
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 for parameters is 100%, with all 5 parameters having clear descriptions. The tool description itself does not add any parameter-level information beyond what the schema provides, so the baseline 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 action ('Get') and the resource ('messages from a stream'), and specifies the scope ('first or last N'). This distinguishes it from sibling tools like get_stream_schema (which retrieves schemas) and get_stream_time_range (which retrieves time ranges), both of which are about metadata rather than message content.
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: if you need to inspect messages from a stream, use this tool. However, it does not explicitly mention when to prefer this over alternatives like execute_query or list_streams, nor does it provide any exclusions or prerequisites. The guidance is implicit rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and openWorldHint, so the description's addition of 'supported by the connected TimeBase server' adds a meaningful caveat about dynamic results. However, it does not detail other behavioral aspects like filtering behavior or output structure, which are left to annotations and schema.
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, grammatically clear sentence that is front-loaded with the action and resource. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema and all parameters are documented in the schema. The description sufficiently defines the tool's core purpose; however, it omits context about filtering options, but the schema covers those. Overall it is complete for a read-only list 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% (each parameter has a description). The tool description does not add any parameter-specific value beyond the schema, so 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 states a specific verb ('List') and resource ('QQL function signatures') with a clear scope ('supported by the connected TimeBase server'). It clearly distinguishes from sibling tools like list_streams or execute_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when you need to know available QQL functions, but it does not explicitly state when to use it versus alternatives or mention any exclusions. The context is clear but not directly instructional.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the fact that stream descriptions are included in the output, which is a minor behavioral detail. It does not disclose edge cases or additional behaviors, but with strong annotations this is adequate.
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, clear, front-loaded sentence with no wasted words. It conveys the essential purpose and output content efficiently.
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 operation with a strong annotation set and an output schema present, the description covers the necessary basics. It does not explicitly explain the output structure, but the output schema compensates. The only minor gap is not mentioning the instance_key parameter, but the schema covers that.
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% for the single optional parameter (instance_key), so the schema already fully documents its meaning. The description adds no additional parameter context, matching the baseline score of 3.
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 ('List') and resource ('TimeBase streams'), and notes the inclusion of stream descriptions. It clearly distinguishes from sibling tools like list_timebase_instances (instances) and list_stream_spaces (spaces), which target different resources.
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 does not explicitly state when to use the tool versus alternatives, but the tool name and sibling context make its primary use case obvious. No exclusions or alternative tool mentions are provided, so guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and openWorldHint=true, and the description does not add behavioral details such as error cases, authentication requirements, or return behavior. It neither contradicts the annotations nor supplements them.
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 verb and object, with no unnecessary words or restatement of the name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple read-only list operation, the schema descriptions, output schema, and annotations, the one-line description is sufficient for an agent to invoke the tool. Some context about the concept of 'spaces' could enhance understanding, but sibling tools provide domain 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?
Both parameters are fully described in the schema (stream_key as 'Stream key to inspect' and instance_key as optional with default null). The description adds no new parameter semantics, so it meets the baseline for 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 ('List') and names the resource ('spaces') with an explicit scope ('for a specific TimeBase stream'), making it distinct from sibling tools like list_streams and list_timebase_instances.
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 'for a specific TimeBase stream' implies the tool is for inspecting spaces associated with one stream, but it doesn't provide explicit when-to-use guidance or contrast with alternative tools such as list_streams, so the guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, which covers safety. The description adds the behavioral caveat 'Limited TimeBase server versions support', alerting users to compatibility constraints. It also specifies that it lists 'active' entities, suggesting a filtering behavior beyond a simple blanket list. No contradiction with annotations is present.
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 consists of one concise sentence plus a brief caveat. It is front-loaded with the core action and resource list, with no filler or redundant phrasing. Every word contributes to understanding the tool's scope and limitation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only listing tool with a full output schema and well-documented parameters, the description covers the essential purpose and a key limitation. However, the caveat 'Limited TimeBase server versions support' is vague and does not specify which versions or how the tool behaves differently across them. Given the availability of output schema and rich parameter documentation, the missing version detail is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so each parameter is already described with meaning (kind enum, limit bounds, instance_key requirement). The description adds no additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate because the schema does the heavy lifting and the description does not need to compensate.
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 with a specific verb ('List') and resource ('active cursors, loaders, connections, and locks'). It distinguishes from siblings like get_timebase_activity_detail by focusing on a broad list of active entities rather than details of a single activity. The additional caveat about limited server versions does not obscure purpose.
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_timebase_activity_detail might be more appropriate for detailed views, nor does it explain any prerequisites or exclusions. The only extra hint ('Limited TimeBase server versions support') is a compatibility warning rather than usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds valuable context by disclosing a limitation: 'Limited TimeBase server versions support,' which is not evident from annotations. This goes beyond what annotations provide, though further details about exact version constraints or runtime behavior are absent.
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, composed of two short sentences. The first sentence immediately states the core purpose, and the second adds the key limitation. No filler or redundant content, every word contributes.
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 status tool with one optional parameter and an existing output schema, the description is largely complete. It identifies the main data returned (version, license, runtime environment) and notes a limitation. Minor ambiguity remains about the exact version support caveat, but overall the description is sufficient given the tool's simplicity and supporting structured data.
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 the instance_key parameter fully described in the schema. The description does not add any additional parameter-level meaning, but the schema already carries the semantic weight. This matches the baseline for high 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 tool's purpose with a specific verb ('Get') and concrete resource targets ('TimeBase version, license, and runtime environment'). It distinguishes itself from siblings like list_timebase_instances and get_server_configuration by focusing on status rather than listing or configuration.
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: use this to retrieve TimeBase status. However, it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or conditions beyond the vague 'Limited TimeBase server versions support.' No comparison with sibling tools is provided, leaving the guidance at an implied level.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotation readOnlyHint=true already indicates a safe read operation. The description adds the word 'configured', implying only configured instances are listed, but does not disclose return format, sorting, or any other behavioral traits. This is minimal additional value beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that states the purpose without any waste. It is perfectly concise for a zero-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, readOnly annotation, and an output schema present), the description is complete. The output schema provides return value details, so the description does not need to elaborate. It clearly communicates what the tool does.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
This tool has zero parameters, so the schema is fully covered. The baseline for no parameters is 4, and the description does not need to add parameter-specific semantics. The single mention of 'configured' helps clarify the scope of listed items but is not about parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'List' with resource 'configured TimeBase server instances', clearly distinguishing it from sibling tools that operate on streams, messages, and activities. The tool's name and description are unambiguous.
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 no explicit guidance on when to use this tool versus alternatives. Usage is implied by the tool name, but no exclusions or alternative references are given. For a simple list tool, the implied usage is acceptable, hence a mid-range score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds a genuinely useful behavioral constraint: 'Limited TimeBase server versions support,' which is not captured by annotations. It does not contradict annotations and provides an extra caveat, earning a solid score despite the sparse description.
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 immediately states the action and the object, followed by a short caveat. It is front-loaded with the verb and resource, contains no filler, and every clause provides necessary information. This is an exemplary concise description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 7 parameters but 100% schema coverage and an output schema present, the description does not need to explain parameters or return value format. It covers the only additional non-schema context—that some server versions are not supported. The tool is a straightforward detail-fetch operation, and the description, though minimal, covers essential context. It could mention that include_instruments only applies to cursor/loader, or that instance_key is required in multi-instance setups, but these are already in the schema, so not necessary for completeness.
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?
Input schema coverage is 100% – every parameter has a description, which is the baseline condition. The tool description itself does not add any parameter-specific meaning beyond what the schema already provides. For example, the enum for 'kind' is fully documented in the schema, and the description does not elaborate on id formats or instance_key requirements. Thus, the description adds no value to 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: 'Get details for one cursor, loader, connection, or lock.' It uses a specific verb ('get details') and a specific resource type, distinguishing it from the sibling list_timebase_activity which lists activity objects rather than retrieving a single object's 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 gives clear context: it is for retrieving details of a single specific activity object, which implies use when you have a known id/kind and need more information than a list provides. However, it does not explicitly mention alternatives or exclusions, such as 'use list_timebase_activity to discover objects first' or 'not supported on all server versions.' The caveat 'Limited TimeBase server versions support' provides some usage warning but not a full when-to-use/not-to-use comparison.
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?
Given the readOnlyHint annotation, the description already benefits from safety disclosure. It adds useful behavioral context: diagnostics are parser-level only, and error_token may be positioned after the actual root cause. This goes beyond annotations and helps set expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and every clause adds value. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete for a tool with a simple purpose, a read-only annotation, a full schema, and an output schema. It covers the key limitation (parser-level only) and an important behavior (error_token position), making it sufficient for an agent to decide when and how to invoke it.
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 3. The description does not add any parameter-specific semantics beyond what the schema already provides, but it does not need to given the high 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 tool compiles TimeBase QQL queries, with a specific verb ('compile') and resource ('TimeBase QQL query'). It also distinguishes itself from full semantic validation, which sets it apart from sibling tools like execute_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by noting it returns only parser-level diagnostics, not full validation, implying it is for quick syntax checks. However, it does not explicitly name alternatives or state when not to use it, so it falls short of the highest bar.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds a valuable behavioral detail beyond the readOnlyHint annotation: that some configuration fields may be undefined or have default values until the first connection is established. This helps the agent interpret potentially unexpected responses.
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 two meaningful clauses: the primary purpose and a useful behavioral caveat. No wasted words; both parts contribute essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, zero-parameter, read-only tool with an output schema, the description is complete. It tells the agent what the tool does and an important edge case (fields may be undefined/default), which is sufficient for selecting and invoking this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so no parameter explanation is needed. According to the rubric, the baseline for 0 parameters is 4, and the description does not need to compensate for any missing 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 the specific verb 'Get' and resource 'MCP server runtime configuration', which clearly states what the tool does. This distinguishes it from sibling tools that focus on streams, timebase instances, queries, and other resources.
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 does not explicitly state when to use this tool or mention alternatives, but it is the only tool among siblings related to server configuration, so usage is implied. The caveat about undefined/default fields gives some contextual guidance for setting expectations.
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:

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

Score Badge

Copy to your README.md:

[![TimeBase-MCP MCP server](https://glama.ai/mcp/servers/epam/TimeBase-MCP/badges/score.svg)](https://glama.ai/mcp/servers/epam/TimeBase-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/epam/TimeBase-MCP'

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