Kontomanager MCP Server

by dhofer

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: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific resources like bills, settings, or phone numbers, with clear separation. However, there is some potential confusion between get_sim_settings and set_sim_setting versus toggle_roaming, as the latter is described as a simplified version of the former, which could lead to misselection in certain contexts.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using snake_case, such as download_bill, get_account_usage, and set_call_forwarding_rule. This uniformity makes the tool set predictable and easy to navigate, with no deviations in naming conventions.
Tool Count5/5
With 11 tools, the server is well-scoped for managing a telecom account, covering key areas like billing, settings, call history, and phone numbers. Each tool serves a clear purpose without redundancy, making the count appropriate for the domain.
Completeness4/5
The tool set provides comprehensive coverage for account management, including CRUD-like operations for settings and access to usage data and bills. A minor gap exists in the inability to directly modify or delete call history or bills, but agents can work around this with the available tools for core workflows.
Average 3.5/5 across 11 of 11 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the action ('Retrieves') but lacks behavioral details such as permissions required, rate limits, whether data is cached or real-time, what 'recent' means temporally, or the format of the returned list. This leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without any wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and the tool's complexity (retrieving historical data), the description is incomplete. It doesn't explain the return format, error conditions, or how 'recent' is defined, which are critical for an agent to use this tool effectively in context with its siblings.
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 parameters with 100% coverage, so no parameters need documentation. The description doesn't add parameter details, but this is acceptable as there are none to explain. It implies scope ('for the active number'), which is useful context, though not strictly a parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Retrieves') and resource ('list of recent calls and SMS messages for the active number'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_account_usage' or 'list_bills', which might also involve retrieving usage-related data, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an active number set), exclusions, or comparisons to siblings like 'get_account_usage' for broader usage data, leaving the agent with minimal context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation, which implies safety, but doesn't cover aspects like authentication needs, rate limits, error conditions, or what the output looks like (e.g., format, structure). This is a significant gap for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Reads the current state of all SIM-related settings') and includes helpful examples in parentheses. Every word earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values are (e.g., JSON structure, data types), which is critical for a read operation. The examples help but don't compensate for the missing behavioral and output 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?
The input schema has 0 parameters with 100% coverage, so there's no need for parameter documentation in the description. The description appropriately doesn't discuss parameters, earning a baseline score of 4 for not adding unnecessary information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Reads') and resource ('current state of all SIM-related settings'), with specific examples like 'roaming status, data barring' that help distinguish it from siblings like 'set_sim_setting' or 'toggle_roaming'. However, it doesn't explicitly differentiate from all siblings (e.g., 'get_call_forwarding_settings' is similar in structure), so it falls short of a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, timing, or compare it to siblings like 'set_sim_setting' or 'toggle_roaming', leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Retrieves' implying a read-only operation, but doesn't clarify permissions required, rate limits, data freshness (e.g., real-time vs cached), or error conditions. For a tool accessing account data without annotation coverage, this leaves critical behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Retrieves the main account overview') and lists key data components. Every word earns its place with no redundancy or fluff, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate for a basic read operation. It specifies what data is returned, which compensates for the lack of output schema. However, without annotations, it misses behavioral details like authentication or rate limits, and it doesn't guide usage relative to siblings, leaving gaps for an agent in complex scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100% (though trivial since there are no parameters). The description doesn't need to explain parameters, and it appropriately doesn't mention any. Baseline for 0 parameters is 4, as there's no parameter information to add beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Retrieves') and resource ('main account overview'), specifying what data is included ('plan details, usage statistics, and credit balance'). It distinguishes from siblings like get_call_history or get_phone_numbers by focusing on account-level data rather than specific telephony features. However, it doesn't explicitly differentiate from list_bills or download_bill which might also relate to account information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication needs), timing (e.g., use for billing inquiries), or exclusions (e.g., not for real-time usage). Given siblings like list_bills for historical billing or get_phone_numbers for number management, the lack of comparative context leaves the agent guessing about appropriate use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation, which implies it's non-destructive, but doesn't address other important aspects: whether it requires authentication, has rate limits, returns structured data, or handles errors. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently conveys the essential information without unnecessary elaboration, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose but lacks details on usage context, behavioral traits, or output format. For a read operation with no structured output schema, more guidance on what the tool returns would be beneficial to achieve full completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter documentation in the description. The description correctly avoids discussing parameters, which is appropriate. A baseline of 4 is applied for zero-parameter tools, as no additional semantic value is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Reads the current call forwarding and voicemail settings for the active number.' It specifies the verb ('reads'), resource ('call forwarding and voicemail settings'), and scope ('for the active number'). However, it doesn't explicitly differentiate from sibling tools like 'get_sim_settings' or 'get_call_history', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an active number), exclusions, or comparisons to sibling tools like 'set_call_forwarding_rule' or 'get_sim_settings'. This leaves the agent with minimal context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states it 'Lists all phone numbers,' implying a read-only operation, but doesn't clarify critical aspects like whether it requires specific permissions, returns paginated results, includes metadata (e.g., number types), or handles errors. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that front-loads the key information ('Lists all phone numbers') without any wasted words. It's appropriately sized for a simple tool with no parameters, and every part of the sentence contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, or usage context. Without annotations or output schema, the agent must infer these aspects, making it incomplete for fully informed use, though sufficient for basic 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?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose. This meets the baseline for tools with no parameters, as there's nothing to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Lists') and resource ('all phone numbers associated with the logged-in account'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'get_call_history' or 'get_account_usage', but the specificity of 'phone numbers' provides inherent distinction. The description avoids tautology by not merely restating the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to be logged in), exclusions, or comparisons to siblings like 'get_call_history' (which might include phone numbers in context) or 'switch_active_phone_number' (which might manage them). Usage is implied by the action but not explicitly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It states this is a 'high-level action' that modifies a SIM setting, implying mutation behavior, but lacks critical details: whether this requires specific permissions, if changes are reversible, potential costs/impacts of enabling roaming, or what the response looks like. The description adds minimal behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place: first states the core action, second provides implementation context. No wasted words, well-structured, and front-loaded with the main purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations, 0% schema coverage, and no output schema, the description is incomplete. It covers the basic action but misses crucial context: error conditions, side effects, authentication requirements, response format, and differentiation from similar tools. The description doesn't provide enough information for safe, effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions the tool toggles roaming based on an 'enabled' parameter, which aligns with the single boolean parameter in the schema. However, it doesn't explain what true/false values mean specifically (e.g., true=enable roaming, false=disable), nor does it provide format or constraint details. The description adds basic meaning but doesn't fully compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as enabling or disabling international roaming, which is a specific verb+resource combination. It distinguishes from siblings by focusing on roaming settings rather than billing, usage, or other SIM settings. However, it doesn't explicitly differentiate from 'set_sim_setting' which might handle similar functionality.
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 context by mentioning it modifies the 'roaming_barred' SIM setting, suggesting it should be used for roaming control. However, it provides no explicit guidance on when to use this tool versus alternatives like 'set_sim_setting' or any prerequisites/warnings about roaming changes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is an update operation (implying mutation), but doesn't mention permissions required, whether changes are immediate or require confirmation, error conditions, or what happens to existing settings. The description provides some parameter constraints but lacks broader behavioral context about the update operation itself.
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 efficiently structured with a clear opening statement followed by bullet points for each parameter. Each bullet adds value by explaining enum codes and constraints. There's minimal waste, though the bullet format could be slightly more polished. The information is front-loaded with the core purpose stated first.
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 4-parameter mutation tool with no annotations and no output schema, the description does well on parameter semantics but lacks broader context. It explains what each parameter means but doesn't cover the update operation's behavior, success/failure responses, or relationship to sibling tools. Given the complexity of updating call forwarding rules, more operational context would be helpful despite the good parameter coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It provides crucial semantic explanations for all enum values: 'alle' (all calls), 'nann' (no answer), 'wtel' (when busy), 'nerr' (not reachable) for condition; 'd' (deactivated), 'b' (voicemail/box), 'a' (another number) for target. It also explains dependencies (target_number required if target is 'a'), format requirements (international format), and clarifies delay_seconds applies only to 'nann' condition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Updates' and resource 'a specific call forwarding rule', making the purpose unambiguous. It doesn't explicitly distinguish from sibling tools like 'get_call_forwarding_settings', but the update vs. get distinction is implied. The description is specific about what gets updated (call forwarding rules with particular parameters).
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 about when to use this tool versus alternatives. While it's implied this is for updating call forwarding rules (versus 'get_call_forwarding_settings' for reading them), there's no explicit comparison or context about prerequisites, dependencies, or when-not-to-use scenarios. The description assumes the user already knows they need to update a forwarding rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool performs a context switch but doesn't clarify what 'active context' entails, whether this affects ongoing operations, requires specific permissions, has side effects, or what happens on success/failure. For a tool that likely changes server state, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each serve distinct purposes: the first states the tool's function, the second provides usage guidance. No wasted words, and information is front-loaded with the core purpose stated immediately.
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 single-parameter tool with no annotations and no output schema, the description covers basic purpose and parameter guidance adequately. However, it lacks details about what 'switching active context' means operationally, what the tool returns, or potential side effects. Given the likely state-changing nature, more behavioral context would be beneficial.
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 description adds meaningful context for the single parameter by explaining that 'subscriber_id' values can be obtained via 'get_phone_numbers'. With 0% schema description coverage and only one parameter, this guidance compensates well. However, it doesn't explain what a 'subscriber_id' represents or its format beyond the sibling tool reference.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('switches') and target resource ('active context to another phone number'), specifying it operates within the 'account group'. It distinguishes from siblings by focusing on context switching rather than data retrieval or settings management. However, it doesn't explicitly differentiate from all siblings (e.g., 'set_call_forwarding_rule' also changes settings).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when needing to change the server's active phone number. It explicitly references an alternative tool ('get_phone_numbers') to obtain required parameter values, offering practical guidance. However, it doesn't specify when NOT to use it or compare with other potential alternatives beyond parameter acquisition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that the tool returns PDF content wrapped in an Image object for serialization, which is useful context beyond basic functionality. However, it doesn't cover potential errors, rate limits, authentication needs, or whether the operation is read-only (implied but not stated).
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 efficiently structured with a clear opening sentence stating the core functionality, followed by bullet points for parameters. Every sentence adds value without redundancy, making it easy to parse and understand quickly.
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 moderate complexity (2 parameters, no output schema, no annotations), the description is adequate but has gaps. It explains what the tool does and parameter meanings but lacks details on return format (beyond 'PDF wrapped in Image'), error conditions, or performance characteristics. For a download operation, more behavioral context would be helpful.
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 description adds meaningful context for both parameters beyond the input schema (which has 0% description coverage). It explains that 'bill_number' is found via 'list_bills' and clarifies the meaning of 'document_type' options ('bill' for main invoice, 'egn' for itemized record). This compensates well for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('fetches', 'returns') and resources ('bill', 'itemized record (EGN)', 'PDF image/document'). It distinguishes from sibling tools by specifying it retrieves PDF documents rather than listing or modifying data like 'list_bills' or 'set_call_forwarding_rule'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool (to fetch specific bills or EGNs as PDFs) and references 'list_bills' as a prerequisite for obtaining bill numbers. However, it doesn't explicitly state when not to use it or name alternatives for similar operations, though the sibling tools suggest different functionalities.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that this is a 'low-level tool' and implies it's for SIM settings, but lacks details on permissions, side effects, or error handling. It adds some context but is incomplete for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by usage notes, all in three concise sentences with zero wasted words. Each sentence earns its place by providing essential guidance.
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 annotations, no output schema, and a mutation tool with 2 parameters, the description is adequate but has gaps: it doesn't cover return values, error cases, or prerequisites like needing an active number. It's minimally viable but not 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?
With 0% schema description coverage, the description compensates by explaining 'setting_name' refers to keys like 'roaming_barred' or 'data_barred' (from 'get_sim_settings'), and 'enabled' controls on/off state. This adds meaningful context beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Enables or disables'), the resource ('a specific SIM setting for the active number'), and distinguishes it from sibling tools like 'toggle_roaming' by noting it's a low-level alternative. It avoids tautology by explaining functionality beyond the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool vs. alternatives: it specifies to use 'get_sim_settings' to see available keys first, and advises that for roaming, 'toggle_roaming' is easier. This clearly defines context and 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that this is a read-only operation (implied by 'fetches' and 'lists'), specifies the scope ('for the active number'), and clarifies what it does NOT do (download PDFs), which is valuable context beyond basic functionality.
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 three concise sentences with zero waste: the first states the purpose, the second clarifies limitations, and the third directs to the alternative tool. Each sentence adds essential information, and the structure is front-loaded with the core functionality.
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 zero-parameter tool with no annotations and no output schema, the description provides complete context: it explains what the tool does, what it doesn't do, and when to use alternatives. The only minor gap is lack of detail on return format (e.g., structure of metadata), but this is reasonable given the tool's simplicity.
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 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on tool behavior rather than parameters, earning a baseline score of 4 for zero-parameter tools that avoid unnecessary parameter discussion.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('fetches a list') and resource ('available bills for the active number'), and explicitly distinguishes it from the sibling tool 'download_bill' by noting it only lists metadata, not PDFs. This provides precise differentiation from related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool (to list bill metadata) and when not to use it (for downloading actual PDFs), and names the alternative tool 'download_bill' for that purpose. This provides clear, actionable guidance for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

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

Score Badge

Copy to your README.md:

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

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/dhofer/mcp-server-kontomanager'

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