Microsoft Fabric RTI MCP Server

Official

by microsoft

Overview Schema Related Servers Score Discussions

Python

Remote

Server Quality Checklist

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

Latest release: v0.6.2
Disambiguation5/5
Tools are clearly separated by domain prefixes (activator_, eventstream_, kusto_, map_), and within each prefix, tools have distinct purposes (e.g., create vs. list vs. get). No overlapping functionality between tools from different domains, and within each domain, operations are uniquely named.
Naming Consistency5/5
All tools follow a consistent snake_case verb_noun pattern, prefixed by domain (e.g., eventstream_add_sample_data_source, kusto_query). The naming is descriptive and predictable across all 39 tools, with no mixing of conventions or ambiguous verbs.
Tool Count3/5
39 tools is on the high side for a single server, but it covers multiple distinct Fabric services (Activator, Eventstream, Kusto, Map). The count is borderline; it could be split into separate servers, but the grouping is logical and each tool serves a clear purpose.
Completeness3/5
Kusto tools are very comprehensive (query, schema, diagnostics, graph, ingestion), and Eventstream tools provide a full builder workflow (create, add components, validate). However, Activator is thin (only create_trigger and list_artifacts), missing update/delete, and Map tools lack advanced operations. Overall, some areas are undercovered.
Average 3.8/5 across 39 of 39 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- 6 of 6 community issues answered or closed in the last 6 months
- 23 commits in the last 12 weeks
- Last stable release on July 16, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description adds no new behavioral context. It fails to disclose what happens on validation failure, whether it returns error messages, or any 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short, containing one line and a docstring. While it is concise, it sacrifices necessary detail, making it minimally acceptable. Extra sentences could improve clarity without significant bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (validation) and the existence of an output schema, the description should provide at least a high-level overview of what validation entails. It does not address common questions like what happens on success/failure or typical response structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%. The description only notes 'Builder session ID' for session_id, which adds no meaningful value beyond the parameter name. The description fails to explain the purpose or format of the session_id, leaving the agent with no additional context.
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 'Validate the current eventstream definition' which clearly identifies the action (validate) and resource (eventstream definition). It distinguishes from sibling tools like eventstream_create or eventstream_get_definition, though it does not specify what aspects are validated.
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 vs alternatives. There is no mention of prerequisites, context, or situations where validation is appropriate versus getting the definition or starting it.
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 destructiveHint=true, indicating mutation. The description adds minimal extra behavioral context: it states the tool creates an eventstream, which is consistent with destructive behavior. However, it does not disclose side effects (e.g., overwriting existing eventstreams), required permissions, or behavior on failure. The return value is vaguely described as 'Creation results'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with no extraneous text. It uses a standard docstring format for parameters and return, making it easy to parse. Every line contributes necessary information. A slight improvement could integrate the param docs into a single flowing sentence, but current structure is clean and efficient.
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?
Despite having only 2 simple parameters and an output schema, the description lacks important context. It does not explain the concept of 'current definition' or indicate prerequisites (e.g., having built a definition via other tools like eventstream_validate_definition). The agent may not know how to obtain or prepare the definition, leading to potential misuse. The tool's destructive nature is acknowledged only through annotations.
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 0% description coverage, so the description bears full responsibility for parameter meaning. It provides brief descriptions for both parameters ('Builder session ID', 'Target Fabric workspace ID') and mentions a return value. These additions are adequate but not rich; they lack details on format, sources, or constraints. Given low schema coverage, the description just meets the baseline.
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 creates an eventstream from a definition, specifying the verb 'Create', the resource 'eventstream', and the source 'from the current definition'. This distinguishes it from related tools like eventstream_create (which likely creates from scratch) and eventstream_validate_definition. However, it does not explain what 'the current definition' refers to (e.g., a builder session's loaded definition), leaving some ambiguity.
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 state prerequisites (e.g., need for a loaded definition) or specify when not to use it (e.g., if creating from scratch). The qualifier 'from the current definition' offers only a weak implicit hint about context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds no additional behavioral context, such as session requirements or side effects. It merely restates the read-only nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and to the point, with no superfluous words. It efficiently states purpose and parameter. However, it could benefit from a bit more structure or context.
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 simplicity of the tool (one parameter, output schema exists), the description is minimally adequate. It covers the basic purpose and parameter but lacks context about the session and how this tool fits into the broader workflow.
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 provides a brief explanation for the parameter ':param session_id: Builder session ID', which adds some meaning beyond the schema's 'Session Id' title. However, it does not clarify what a Builder session is or how to obtain it, leaving ambiguity.
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 retrieves the current eventstream definition. The verb 'Get' and noun 'current eventstream definition' are specific. However, it does not differentiate from sibling tools like eventstream_get_definition or eventstream_get, which may have similar purposes.
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 specify prerequisites, context, or when not to use it. Sibling tools exist but are not mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are readOnlyHint=false and destructiveHint=false, but the description does not elaborate on behavioral traits beyond noting optional parameters. It fails to disclose potential side effects, failure handling, or state changes.
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 reasonably front-loaded with the main action but includes a verbose parameter list in docstring style. Some redundancy exists (e.g., repeating parameter names).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers core functionality and mentions the return type, but given the tool's complexity (5 parameters, ingestion operation), it omits details like data size limits, error handling, and output schema specifics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description partially compensates by explaining each parameter (e.g., 'Comma-separated data string to ingest'). However, it lacks details on constraints, formats, or allowed values.
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 ('Ingests inline CSV data into a specified table') with clear verb and resource. It distinguishes from sibling tools like kusto_query and kusto_command by focusing on data ingestion.
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 basic usage (data as comma-separated string, optional database) but lacks guidance on when to use this tool versus alternatives, prerequisites, or limitations.
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 indicate destructiveHint=true, but the description does not elaborate on destructive behavior. It only states 'Update' which is consistent with readOnlyHint=false, so no contradiction, but no added context.
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 short but includes a docstring that repeats the purpose. It is adequately front-loaded but could be more concise.
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 destructive hint and lack of parameter details, the description is incomplete. It does not explain the impact of updating the definition or any constraints on the definition object.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description merely lists parameter names with types already in the schema. No extra meaning or constraints are provided for the 'definition' object.
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 'Update a Map item's definition by workspace and item ID', providing a specific verb and resource. It distinguishes from siblings like map_create and map_update.
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 mentions authentication but lacks explicit guidance on when to use this tool versus alternatives like map_update. No when-not conditions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false, but the description adds minimal behavioral context beyond the 'deprecated' labels on endpoint_url and method parameters. It does not disclose potential side effects, authentication requirements, or error consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a clear one-sentence purpose followed by a parameter list. It avoids unnecessary words, though the structure could be more streamlined. Overall, it is efficient and front-loaded.
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 (6 parameters, many optional/deprecated) and the existence of an output schema, the description covers the main purpose and parameter meanings but lacks return value descriptions, error handling, or usage examples. It is adequate but not 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?
With 0% schema description coverage, the description compensates by listing each parameter and providing brief explanations (e.g., 'List of stream names that feed this destination'). However, it lacks format details, constraints, or examples for parameters like 'headers' and 'method'. It adds some value but not full clarity.
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 'Add a custom endpoint destination to the eventstream definition,' specifying the verb and resource. It distinguishes from sibling tools like 'eventstream_add_custom_endpoint_source' and 'eventstream_add_eventhouse_destination' by targeting a custom endpoint specifically.
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 'eventstream_add_eventhouse_destination'. It does not specify prerequisites, conditions, or exclusions, leaving the agent without context for appropriate invocation.
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 indicate readOnlyHint=true and destructiveHint=false. The description adds no additional behavioral context such as side effects, permissions, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise and front-loaded: two sentences with zero waste. Every sentence serves a 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?
For a simple list tool with output schema, the description is minimally adequate. It states the action and return type, but lacks context on filtering, ordering, or limits, which could be added.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It adds that workspace_id is a UUID, which is useful, but does not provide further details like format or source, missing an opportunity to fully 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 lists all Activator artifacts in a workspace, using a specific verb and resource. It distinguishes from sibling tools like activator_create_trigger and map_list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use vs alternatives or when not to use. It simply says 'use this to list', lacking explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's lack of behavioral details is acceptable. The description does not add any context beyond the annotations, but also does not contradict them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short at two sentences, but the second sentence ':return: Available components' is somewhat redundant given the first sentence. It could be more concise by removing this line.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and a likely simple output, the description is minimally sufficient. However, it does not clarify what 'components' are in this context, which might leave the agent uncertain about the return format without consulting the output schema.
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?
There are no parameters, and schema coverage is 100%. The description adds no parameter information, which is fine as none is needed. Baseline for 0 parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List available components for building eventstreams', which matches the tool name. However, it does not explicitly differentiate from sibling tools like 'eventstream_list' or 'eventstream_add_sample_data_source', though the name itself suggests a distinct 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?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions, leaving the agent without usage direction.
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 indicate readOnlyHint=false and destructiveHint=false, but the description adds no behavioral context beyond 'Add'. It does not disclose side effects, authorization needs, or the mutation's scope. With annotations already conveying mutability, the description offers minimal additional transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured as a docstring with a clear purpose sentence followed by parameter explanations. It is appropriately sized for 9 parameters—each line adds value without excessive verbosity. Front-loading the main action is effective.
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 output schema is available (reducing need to explain return), the description lacks context about how this destination fits into the broader eventstream workflow (e.g., relationship to start_definition, validation). It also doesn't clarify when to choose Eventhouse over other destination 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?
Schema description coverage is 0%, so the description must compensate. It provides one-line explanations for all 9 parameters (e.g., 'Builder session ID', 'Target database name'), which adds meaning beyond the schema's type/name-only info. It also notes optional parameters and defaults, significantly aiding parameter understanding.
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 'Add an Eventhouse destination' and the target resource 'eventstream definition'. This verb+resource combination distinguishes it from sibling tools like eventstream_add_custom_endpoint_destination or eventstream_add_derived_stream.
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 (e.g., custom_endpoint or derived_stream). It lacks prerequisites, context, or any conditions under which this destination is appropriate.
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 mark the tool as read-only and non-destructive. The description adds that 'Authentication is handled transparently using Azure Identity,' which is useful context beyond annotations. However, it does not disclose any other behavioral traits (e.g., caching, pagination, or error behavior), and annotations already cover the key safety aspects, so the incremental value is moderate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short (two sentences plus param docs) and front-loaded with the core purpose. It avoids unnecessary fluff. The param documentation follows a clear pattern. Slightly wordy due to Rust-style doc comment syntax, but still efficient. Every sentence 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 tool's low complexity (2 required params, output schema present, readOnlyHint in annotations), the description covers the essential purpose and authentication behavior. It could mention what 'definition' includes (e.g., JSON structure) or any limitations, but for a simple getter with an output schema, it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description provides basic parameter documentation ('workspace_id: The workspace ID (UUID), item_id: The eventstream item ID (UUID)'). This adds meaning beyond the raw schema (which only has titles and types), but it is minimal—lacking format constraints, examples, or any deeper semantics about how IDs are used or validated.
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 'Get the definition of an Eventstream item', which is a specific verb-resource combination. It effectively distinguishes from sibling tools like eventstream_get (likely retrieving metadata) and eventstream_get_current_definition (retrieving only current), providing unambiguous 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 guidance on when to use this tool versus alternatives like eventstream_get or eventstream_get_current_definition. With 18+ eventstream-related siblings, explicit context about choosing this over others is missing, making it hard for an AI to select optimally.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, and the description confirms it executes management commands. However, it adds no further behavioral details like required permissions or effect on data.
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?
Very concise: two sentences plus a param listing. Front-loaded with purpose, no unnecessary words.
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?
Provides basic purpose and parameters but lacks context on prerequisites, errors, or when to use over similar tools. Output schema exists but description doesn't complement it with additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but description only restates parameter names and optionality. Does not explain what constitutes a valid command, URI format, or client request properties structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it executes a Kusto management command on a specified database. The use of 'management command' distinguishes it from query siblings like kusto_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. Doesn't explain that management commands differ from queries, nor provides context about when a management command is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, and the description confirms the destructive nature. However, it does not disclose potential side effects or irreversibility beyond what annotations provide.
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?
Extremely concise: two sentences with a clear purpose and parameter/return documentation. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and an output schema, the description is minimally complete. It lacks context about session requirements or what 'start over' entails, but suffices for basic understanding.
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 adds a brief explanation for 'session_id' as 'Builder session ID', which provides some meaning beyond the parameter name. However, with 0% schema description coverage, more detail would be beneficial.
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 clears the current eventstream definition and starts over, using a specific verb 'clear' and resource. It distinguishes from sibling tools like 'eventstream_delete' or 'eventstream_get_current_definition'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'eventstream_delete' or 'eventstream_start_definition'. The description does not mention preconditions or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it returns results as a list of dictionaries, which is basic. No additional behavioral traits (e.g., rate limits, error behavior) are disclosed, but nothing contradicts annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a clear purpose statement followed by a structured docstring listing parameters. It avoids extraneous text, though the docstring format is slightly redundant with the input schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that annotations cover safety and output schema exists, the description adequately explains the core purpose and key parameters. It does not address edge cases like timeouts or authentication, but for a straightforward query tool, it's 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?
Schema coverage is 0%, so description must compensate. It provides brief meanings for each parameter (e.g., 'The KQL query to execute'), which adds value over bare names. However, it lacks format details or constraints, making it merely adequate.
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 'Executes a KQL query on the specified database,' which provides a specific verb (Executes) and resource (KQL query on database). This distinguishes it from siblings like 'kusto_command' (admin commands) and 'kusto_describe_database' (describing metadata).
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 explicit guidance on when to use this tool versus alternatives. It mentions fallback to default database but does not contrast with other query or data tools, leaving the agent without decision context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true (destructive) and readOnlyHint=false (not readonly). The description adds that authentication is 'handled transparently using Azure Identity' and mentions return type (error details or empty response). This provides some context beyond annotations, but not deeply detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is succinct (two sentences plus parameter list) and front-loaded with the core action. No unnecessary words. Could be slightly more structured, but efficient overall.
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 delete operation with two required parameters and an output schema (not shown), the description covers essential aspects: purpose, parameters, auth handling, and return. Adequate for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description partially compensates by indicating both parameters are UUIDs. However, it does not specify format constraints or expected values beyond the type, leaving gaps in semantic 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 clearly states the action ('Delete'), the resource ('Map item'), and the required identifiers ('workspace and item ID'). It unambiguously distinguishes from sibling tools like map_create, map_get, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives (e.g., map_update or map_get). Does not mention prerequisites or scenarios for use.
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 the tool as not read-only (readOnlyHint=false) and destructive (destructiveHint=true). The description adds minimal behavioral context beyond stating it creates an item and that authentication is transparent. It does not detail side effects, permissions, or other behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a concise docstring with parameter list and purpose. It is front-loaded with the action and includes a return statement. It is efficient but could be slightly more concise by removing the param details if schema descriptions existed.
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 an output schema exists (not shown), the return value line is acceptable. The description covers key parameters but lacks details on constraints (e.g., map_name uniqueness, definition structure). It is minimally adequate for a create tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description provides meaningful parameter explanations: workspace_id (UUID), map_name, definition (auto-generated if not provided), description (optional), folder_id (defaults to root folder). This adds significant value beyond the property types and names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it creates a Map item in Microsoft Fabric. The verb 'Create' and resource 'Map item' are specific and distinct from sibling tools like map_delete, map_get, etc.
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 creating a map but lacks explicit guidance on when to use this tool versus alternatives, or conditions for use. It mentions authentication handling but does not specify prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark destructiveHint=true, so the description adds some value by specifying parameter constraints (naming rules, max length). However, it does not elaborate on what 'destructive' entails or any side effects beyond the update.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with the purpose. Every sentence adds value: purpose, auth, parameter docs. No wasted words, though the param list could be integrated more succinctly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple update tool with 4 parameters (2 required) and an output schema, the description covers purpose, auth, and parameter constraints. However, it omits that display_name and description are optional (can be null), and does not mention what the output contains beyond 'updated map details'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description compensates by specifying that workspace_id and item_id are UUIDs, and adding constraints for display_name and description (naming rules, max 256 chars). This adds meaning beyond the schema's type 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 action 'Update a Map item's display name and description' with specific verb and resource. It distinguishes from sibling tools like map_create, map_delete, and especially map_update_definition, which updates a different aspect.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like map_update_definition. The description only mentions authentication handling, which is not a usage guideline. Missing context on prerequisites or scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate the tool is not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds that it starts a session but provides no details about side effects, state changes, or required permissions. With annotations carrying the safety profile, a 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise: three sentences with no redundancy. The docstring-style format clearly separates purpose, parameters, and return value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present (not shown), the description doesn't need to detail return values, but it still gives a vague summary. The tool has only 2 parameters and few complexities, so the description is adequate but lacks depth for a complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains the 'name' parameter as 'Name of the eventstream to create' and 'description' as 'Optional description', adding meaning beyond the schema's type-only definitions. However, it could be more detailed (e.g., constraints on name format).
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: starting a new eventstream definition builder session. The verb 'start' and resource 'eventstream definition builder session' are specific, and the tool is distinct from siblings like eventstream_create and eventstream_get_definition.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The description does not mention prerequisites, when to start a session, or when other tools like eventstream_create_from_definition would be more appropriate.
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 destructiveHint=false, so the safety profile is known. The description adds only the return type (list of dicts) and a basic parameter description, but no extra behavioral context such as permissions, side effects, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph with a clear purpose statement followed by parameter documentation. It is relatively concise but could benefit from more structured formatting (e.g., separate sections).
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 existence of an output schema, the description's mention of return type (list of dicts) is sufficient. It covers all parameters and the default database behavior. For a read-only tool with good annotations, it is adequately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description compensates by explaining each parameter (entity_name, entity_type, cluster_uri, database, client_request_properties) and their optionality. This adds meaning beyond the schema's title-only 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 it retrieves schema information for a specific entity in a Kusto database. The verb 'retrieves' and resource 'entity' are specific, and it distinguishes from siblings like kusto_describe_database (describes database itself) and kusto_list_entities (lists entities).
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 explains optional database usage but does not provide explicit guidance on when to use this tool versus related tools like kusto_describe_database or kusto_list_entities. No alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds that authentication uses Azure Identity, which provides context beyond annotations. However, it does not elaborate on other behaviors like error handling or response details.
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 with only three short sentences, front-loading the main purpose. The parameter documentation is structured and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, the description's minimal return statement is acceptable. However, it could mention what the Map item details include or error cases, making it only moderately complete.
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 has 0% description coverage, but the description explains that workspace_id and item_id are UUIDs and identifies their roles. This adds meaningful context beyond the schema's type 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 it retrieves a Map item by workspace and item ID, using a specific verb and resource. It distinguishes from sibling tools like map_create, map_delete, and map_list, which have different operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as map_list for listing or map_get_definition for getting definition. The description lacks explicit conditions or exclusions.
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 and destructiveHint, so safety is clear. The description adds value by noting transparent Azure Identity authentication, but it does not disclose limitations like pagination or performance considerations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences plus docstring-like parameter/return notes. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one parameter and an output schema (not shown but present), the description covers purpose, parameter, and return. It could mention that it lists all items (no filtering), but it's mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% (no parameter descriptions in schema), but the tool description compensates by explaining the workspace_id parameter as a UUID and its purpose. This adds meaningful semantics beyond the type-only 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 lists all Eventstream items in a workspace. The verb 'List' and resource 'Eventstream items' are specific. It distinguishes from siblings like eventstream_get (retrieves single item) and eventstream_create.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., other listing tools or filtering options). The description lacks exclusions or context for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate it is not read-only and not destructive, but the description adds context by detailing parameters and the return value ('Updated definition summary'). It discloses the modification behavior and output, though it omits prerequisites or 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 very concise: one sentence for purpose, followed by clear parameter docs using standard RST format. No extraneous text; every sentence adds value.
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 description covers purpose, all parameters, and the return value. Coupled with an output schema (present but not shown), it provides sufficient context for a simple add tool. Missing are error conditions or prerequisites, but these are minor given the low 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?
With 0% schema description coverage, the description's :param lines provide essential meaning: session_id is a builder session ID, sample_type lists examples, and source_name can be auto-generated. This compensates well, though more detail on sample_type options and validation would be beneficial.
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 ('Add a sample data source') and the resource ('to the eventstream definition'), distinguishing it from sibling tools that add custom endpoints or derived 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?
No explicit guidance on when to use this tool versus alternatives (e.g., eventstream_add_custom_endpoint_source). The description only implies its function through the name 'sample', but does not provide context or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds minimal behavioral context beyond listing the return type. It does not discuss pagination, limits, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with a clear purpose then parameter details. However, the docstring format (':param' and ':return') is slightly verbose. It could be more concise without losing clarity.
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 listing tool with multiple entity types, the description covers the core functionality and dependencies adequately. It lacks edge-case context like handling of missing required database or system entities, but an output schema exists to specify return format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description fully compensates by clearly defining each parameter, including valid entity_type values, when 'database' is required, and the purpose of client_request_properties.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (Retrieves), the resource (list of all entities), and the scope (in the Kusto cluster). It enumerates specific entity types, distinguishing it from sibling tools like kusto_query or kusto_describe_database_entity.
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 explains the role of the 'database' parameter for different entity types but does not provide when-to-use or when-not-to-use guidance relative to other tools. No explicit alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate it's not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds value by noting that endpoint_url is deprecated and mentioning the return type 'Updated definition summary', giving context beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and efficiently structured with docstring-style parameter explanations. No unnecessary sentences; each line adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 parameters) and the existence of an output schema, the description covers the action, parameters, and return type adequately. Minor missing context about session prerequisites is not critical for this operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the schema has no descriptions. The description compensates fully by explaining all three parameters: session_id as 'Builder session ID', source_name as auto-generated, and endpoint_url as deprecated with an alternative.
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 begins with a clear verb and resource: 'Add a custom endpoint source to the eventstream definition.' This distinguishes it from siblings like eventstream_add_custom_endpoint_destination and eventstream_add_sample_data_source by specifying 'custom endpoint source'.
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 adding a destination or derived stream. The description implies usage by describing the action, but lacks explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint=true and readOnlyHint=false, which align with 'Update.' The description adds value by noting that 'Authentication is handled transparently using Azure Identity,' providing context beyond annotations. However, it does not detail side effects or return format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with a clear docstring format. It includes essential information (purpose, auth, param docs) without extraneous content. The structure is front-loaded with the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 simple parameters and an output schema (not described), the description covers purpose, auth, and param meanings. It lacks explanation of the output structure and potential partial updates, but is otherwise sufficient for a simple update operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description includes a docstring explaining each parameter: workspace_id (UUID), item_id (UUID), and definition (updated eventstream definition). This adds meaning beyond the schema's types and titles. The return value is mentioned but not parameter-specific.
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 explicitly states 'Update an Eventstream item by workspace and item ID,' clearly specifying the verb (update), resource (Eventstream item), and identifiers (workspace and item ID). Among sibling tools, this distinguishes it from create, delete, and get operations.
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 updating an existing eventstream item but does not provide explicit guidance on when to use versus alternatives (e.g., create, delete), nor does it state prerequisites or exclusion conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description reinforces this by explaining the diagnostic (read-only) nature and adds transparency about partial failure behavior: each section returns errors independently without affecting others.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: first sentence states purpose, then a second paragraph explains error handling, parameter details in param/return format, and a list of sections. It's slightly verbose but every sentence adds value, and front-loading is effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has multiple diagnostic sections and an output schema (though not shown), the description completes the picture by listing the sections and explaining the return format (dictionary with lists or error dicts). It adequately covers behavior, parameters, and return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema coverage at 0%, the description carries the full burden. It explains cluster_uri, database, and client_request_properties in the docstring, providing meaning beyond the schema's type definitions. However, it does not give examples or constraints for client_request_properties.
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 runs a suite of diagnostic commands and returns a JSON summary of the cluster's current state. It uses specific verbs ('runs', 'returns') and identifies the resource ('Kusto cluster'). Among siblings like kusto_query and kusto_command, this tool is distinct as a comprehensive diagnostics suite.
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 notes that sections run independently and handle errors gracefully, but it does not explicitly state when to use this tool versus alternatives like kusto_query or kusto_command. The context implies it's for overall health checks, but clear usage boundaries are missing.
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 show destructiveHint=true; description adds context on transparent authentication via Azure Identity and auto-generation behavior for IDs and names. Does not cover failure modes or idempotency, but adds meaningful detail 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with bullet points and front-loaded purpose. Every sentence adds value, though slightly verbose with repeated option explanations. Could be more succinct but is clear.
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 complexity (5 params, destructive action) and presence of an output schema, the description covers creation scenarios adequately. Missing details on error handling and parameter constraints, but sufficient for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully explains all 5 parameters including auto-generation rules for eventstream_name, eventstream_id, and definition. Provides clear, actionable semantics for each parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Create an Eventstream item in Microsoft Fabric' with specific verb and resource. Distinguishes from sibling eventstream_create_from_definition by outlining auto-generation vs full definition options.
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?
Describes four usage patterns (name only, ID only, both, full definition) but does not explicitly compare with sibling tools like eventstream_create_from_definition, leaving when-to-use somewhat implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds value by noting that authentication is handled transparently via Azure Identity. This extra context is beneficial beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences plus a docstring. Every sentence serves a purpose: stating the core function, mentioning authentication, and describing parameters. No extraneous content.
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 get-by-ID tool, the description covers the purpose and parameters adequately. The presence of an output schema means return values do not need explanation. Minor omission: no mention of error handling for invalid IDs, but this is acceptable.
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 0% description coverage, so the description's docstring provides meaning for both parameters by specifying they are UUIDs. This adds semantic value beyond the schema's type and title.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'Eventstream item' along with the specific identifiers (workspace ID and item ID). This distinguishes it from sibling tools that perform other operations like create, delete, or list.
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 to retrieve an eventstream item by its IDs, but it does not provide explicit guidance on when to use this tool over alternatives like eventstream_get_current_definition or eventstream_get_definition. No exclusion criteria are given.
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 indicate readOnlyHint=true. The description adds that the result could be null if no services are configured, and details the return object structure, providing useful behavioral context beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise: two sentences plus a return type note. No wasted words, front-loaded with the main action.
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 no parameters and an output schema described in text, the description is adequate. It lacks error handling or permission notes, but for a simple read-only list tool, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, and schema coverage is 100% (empty). Baseline score of 4 applies as the description does not need to add parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Retrieves' and the resource 'list of all Kusto services known to the MCP', which distinguishes it from sibling tools like kusto_query or kusto_command. The return type is also specified.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives, but the purpose is straightforward. For a simple retrieval tool with clear context, a moderate score is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds context: default database handling, parameter descriptions, return type (list of dicts). No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single paragraph clearly front-loaded with purpose. Parameter descriptions are compact and informative. Slightly verbose with :param notation, but efficient overall.
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?
Covers all parameters, defaults, and return type. Output schema exists, so return description is supplementary. Lacks error conditions or edge cases, but adequate for a read-only sample tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, description fully compensates: explains each parameter's purpose, default values, and optionality. Adds meaning beyond schema titles.
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?
Precisely states action: 'Retrieves a data sample from the specified entity.' Includes contextual detail about default database. Distinct from siblings like kusto_query and kusto_list_entities.
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?
Mentions database fallback behavior but does not explicitly state when to use this tool over alternatives (e.g., kusto_query or kusto_list_entities). No when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds that authentication is handled transparently via Azure Identity, which is useful context beyond the annotations. No contradictions.
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 at four sentences, covering purpose, auth, and both parameters with no unnecessary words. Every sentence serves a clear function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 required string params, read-only, output schema present), the description covers purpose, auth, parameters, and return value. It could mention what a 'map definition' contains, but the output schema handles that.
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 0% description coverage, so the description compensates by adding the UUID format for both parameters and explicitly stating they are required. This adds significant meaning beyond the bare schema types.
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 'Get the definition of a Map item,' using a specific verb and resource. It distinguishes from sibling tools like map_get (which retrieves the map object) and map_update_definition.
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 mentions transparent authentication but does not provide explicit guidance on when to use this tool versus alternatives (e.g., map_get). Usage context is implied but not clearly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint=true, but the description does not address destructiveness. However, it adds critical behavioral notes: the API does not validate whether the KQL query matches the data schema, and it warns about double-checking queries. It also describes output (URL, ID, displayName).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured as a docstring with parameter list and critical note. It is front-loaded with the purpose. While somewhat lengthy, every sentence provides value. Could be slightly more concise.
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 high parameter count (11) and lack of annotations, the description covers all parameters, includes return value details, and adds a critical caveat about query validation. This is sufficient for a correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining each of the 11 parameters, including types (UUID, email, integer), default values (alert_type, polling_frequency), and constraints (polling frequency must be one of 5,15,...). The KQL query parameter includes a critical warning about schema compatibility.
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: 'create an alert that will fire when the source generates data.' It uses a specific verb ('create') and resource ('alert/trigger'), and distinguishes itself from siblings like 'activator_list_artifacts' which only lists artifacts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (creating a trigger) but does not explicitly state when not to use it or provide alternatives. No guidance on prerequisites or comparisons with other tools, though the sibling list suggests it is the correct tool for creation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false. The description adds behavioral context beyond annotations, such as the automatic connection logic for input_nodes when only one stream exists. No contradictions.
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 with a clear front-loaded purpose followed by parameter details. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters and an output schema, the description covers purpose, parameter semantics, and return value ('Updated definition summary'). No missing essential information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description explains all three parameters (session_id, stream_name, input_nodes) with clear semantics. It details the auto-connection behavior of input_nodes, adding value 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 starts with 'Add a derived stream to the eventstream definition.' This is a specific verb+resource combination that clearly distinguishes it from sibling tools like eventstream_add_custom_endpoint_destination or eventstream_add_sample_data_source.
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 guidance for the 'input_nodes' parameter (auto-connect behavior when None), but does not explicitly state when to use this tool versus alternatives or when not to use it. Usage context is implied but not definitive.
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 provide destructiveHint=true and readOnlyHint=false. Description adds that authentication is handled transparently and returns deletion confirmation, which provides context beyond annotations. However, it does not elaborate on the scope of deletion.
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?
Extremely concise: two sentences plus param docs. No redundant information; front-loaded with the core action.
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 delete tool with two params and an output schema, the description covers purpose, parameters, return, and auth. It could mention irreversibility but is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so description compensates by documenting both parameters as UUIDs and clarifying their roles. This adds significant meaning 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?
Description clearly states 'Delete an Eventstream item by workspace and item ID', providing a specific verb and resource. It is distinct from sibling tools like eventstream_get or eventstream_list.
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?
Description implies usage from the verb and resource but does not explicitly state when to use this tool versus alternatives. No when-not or exclusion criteria provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate a safe read operation. The description adds context about the limitations of schema information (e.g., dynamic columns). It also notes the return type. No contradictions 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear opening sentence, a useful recommendation note, and parameter documentation. No redundant information, though slightly lengthy.
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 presence of an output schema, the description adequately covers the tool's purpose, parameter details, and a complementary tool recommendation. It is complete for the task of describing database schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by documenting all three parameters: cluster_uri, database, and client_request_properties with clarifications. The optional nature and default of client_request_properties are explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves schema information for all entities in a database. The verb 'retrieves' and resource 'schema information for all entities' are specific. It distinguishes from sibling tools like kusto_describe_database_entity and kusto_list_entities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly recommends using kusto_sample_entity() for actual data samples when schema alone is insufficient. It provides a clear usage alternative, though it does not specify other when-not scenarios.
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 indicate read-only and non-destructive nature. The description adds behavioral details: cluster type auto-detection, fallback to .show version, and that it returns None on failure. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is clear and front-loaded with purpose. Parameter docs are structured but could be integrated more compactly. Still concise overall.
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?
Covers purpose, cluster detection, fallback, parameters, and return. For a simple URL-building tool with an output schema, this is fully complete.
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 provides only titles. Description adds parameter descriptions (cluster_uri, database, query) and return value. This adds significant meaning beyond the schema, though could include format or encoding details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it builds a deeplink URL for a KQL query, specifying different target UIs for Azure Data Explorer and Fabric. This clearly distinguishes it from sibling tools like kusto_query that execute queries.
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 explains when to use (to open a query in a web UI) and the auto-detection fallback behavior. It does not explicitly list alternatives, but the context from sibling tools makes it clear when not to use.
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 indicate read-only and non-destructive nature. The description adds value by detailing default database behavior and return format (list of dictionaries as JSON), going 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficient, starting with purpose and constraints, then parameter details. Some redundancy exists (default database mentioned twice), but overall it's well-organized and not overly verbose.
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 description covers the tool's core functionality, constraints, and parameters adequately. For a simple read-only tool with an output schema, missing elements like error handling or sibling differentiation are minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining each parameter: command, cluster_uri, database (including default behavior), and client_request_properties. This adds essential meaning 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 'Executes a Kusto .show management command' with a specific verb and resource. It further distinguishes by limiting to .show commands, which differentiates it from sibling tools like kusto_command or kusto_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 explicitly says 'Only .show commands are accepted,' providing a clear constraint. However, it does not mention alternatives like kusto_command for other commands, so it lacks explicit when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, ensuring the agent knows it's safe. The description adds detailed behavioral insights: snapshot fallback, default database behavior, graph-match query constraints (e.g., required project clause, property renaming), and the absence of id() and type functions. These exceed what annotations provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with an overview, parameter docs, critical notes, and three examples. While lengthy, each section is valuable and the critical notes are essential for correct usage. It is front-loaded with the purpose and param docs before details, but could potentially condense examples to one or two.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (graph queries with special constraints), zero schema parameter descriptions, and the existence of an output schema, the description fully covers: snapshot behavior, default database, all parameter meanings, critical constraints (no id(), no type, property renaming, variable-length path syntax), and return format. Multiple examples further clarify usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description includes a parameter documentation section with 'param' lines explaining each parameter's purpose and constraints. It clarifies 'graph_name' as the graph name, 'query' as KQL query with project clause requirement, 'database' as optional default, and 'client_request_properties' as optional dictionary. This adds essential meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'Intelligently executes a graph query using snapshots if they exist, otherwise falls back to transient graphs,' specifying the verb 'executes', the resource 'graph query', and the scope of snapshot usage. This distinguishes it from sibling tools like kusto_query which handle regular Kusto queries.
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 usage context for graph queries with critical notes and examples, but does not explicitly contrast with alternative tools such as kusto_query or provide when-not-to-use guidance. The examples demonstrate usage but lack comparative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds that authentication is handled transparently via Azure Identity and specifies return type (list or error details), providing additional behavioral context 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?
Description is two concise sentences plus standard param/return documentation lines with no wasted words. Purpose is front-loaded, making it efficient for the agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one parameter and an output schema, the description covers purpose, authentication, parameter meaning, and return type. It is complete and leaves no gaps for the agent to infer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but description includes a clear parameter documentation line ':param workspace_id: The workspace ID (UUID)', which adds meaningful guidance about the parameter's purpose and expected format beyond just the schema's type string.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List all Map items in a workspace', using specific verb 'list' and resource 'Map items'. It distinguishes from siblings like map_get (single item) and map_create (create).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description indicates when to use (to list all Map items in a workspace). It does not explicitly state when not to use or mention alternatives, but the sibling tools context provides that implicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the tool does not execute the query, only generates the plan, and describes the return structure including error handling. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections (param, return, critical), uses bullet points for return keys, and is appropriately sized. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complexity is moderate with 4 params and a detailed return object. The description fully covers the purpose, parameters, return structure, and usage context. With an output schema present, the return documentation is sufficient. It clearly differentiates from siblings like kusto_query.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description manually documents each parameter (query, cluster_uri, database, client_request_properties) and the return value with detailed keys, adding significant meaning beyond the raw 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 'Retrieves the query execution plan without actually running the query', specifying the verb and resource. It distinguishes from execution by emphasizing that no query is run.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says 'This is significantly lighter than execution and useful for understanding performance characteristics and estimating query impact' and 'Critical: This does NOT execute the query'. This tells when to use (estimation) and when not (actual execution).
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:

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

Score Badge

Copy to your README.md:

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

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