LINE Bot MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation3/5
There is significant overlap between broadcast/push variants (e.g., broadcast_text_message vs broadcast_messages vs broadcast_flex_message) and between Gemini-integrated tools (gemini_command vs push_gemini_flex vs push_gemini_text vs ai_query_mssql), which could lead to confusion about which tool to use for similar tasks. However, the descriptions help clarify some distinctions, such as between generic and specific message types.
Naming Consistency4/5
Most tools follow a consistent snake_case verb_noun pattern (e.g., broadcast_text_message, get_profile, delete_rich_menu), with clear actions like broadcast, push, get, set, delete, query, and export. Minor deviations include ai_query_mssql (starts with 'ai_') and gemini_command (uses 'command' instead of a more specific verb), but overall the naming is predictable and readable.
Tool Count3/5
With 18 tools, the count feels borderline heavy for a LINE bot server, as it includes many overlapping or specialized variants (e.g., multiple broadcast and push tools). While the scope covers messaging, user management, rich menus, and database queries, the set could be streamlined without losing functionality, making it slightly overwhelming for an agent to navigate.
Completeness4/5
The tool surface provides good coverage for LINE bot operations, including messaging (broadcast/push with text/flex), user profile retrieval, rich menu management (list/set/cancel/delete), and database queries (MSSQL with AI integration). Minor gaps include lack of tools for updating user data or handling webhook events, but core workflows are well-supported, allowing agents to perform essential tasks without major dead ends.
Average 3.3/5 across 18 of 18 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 is passing
This repository is licensed under Apache 2.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. While 'broadcast' implies a write operation that sends messages, it doesn't mention important behavioral aspects like rate limits, authentication requirements, whether this is a one-way broadcast (no replies), potential costs, or what happens on failure. The description is too minimal for a mutation 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 extremely concise - a single sentence that efficiently communicates the core functionality. Every word earns its place with no wasted verbiage. It's front-loaded with the essential information about what the tool does.
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 and no output schema, the description is insufficiently complete. It doesn't explain what happens after broadcasting (success indicators, error conditions), doesn't address the sibling tool relationships, and provides minimal behavioral context. The agent would need to guess about important operational aspects of this broadcast functionality.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents the 'messages' parameter thoroughly with its text and flex message structures. The description adds minimal value by mentioning 'one or more LINE messages' and 'text/flex' types, but doesn't provide additional semantic context beyond what's in the schema. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('broadcast'), the resource ('LINE messages'), and the target ('all followers'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'broadcast_flex_message' or 'broadcast_text_message', which appear to be more specialized versions of this generic tool.
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 'broadcast_flex_message' or 'broadcast_text_message'. It mentions 'generic' but doesn't explain what makes it generic or when to choose it over the more specific siblings. No prerequisites, exclusions, or comparison context is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Delete') but doesn't mention permissions required, whether deletion is permanent/reversible, rate limits, or what happens to associated data. For a destructive operation with zero annotation coverage, this leaves critical gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose with no wasted words. It's appropriately sized and front-loaded, 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?
For a destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain behavioral implications (e.g., permanence, side effects) or return values, leaving the agent with incomplete context for safe invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'richMenuId' fully documented in the schema. The description doesn't add any parameter details beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without compensating value.
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 ('Delete') and resource ('a rich menu from your LINE Official Account'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'cancel_rich_menu_default' or 'set_rich_menu_default', which would require explicit comparison to earn a 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?
No guidance is provided on when to use this tool versus alternatives like 'cancel_rich_menu_default' or 'set_rich_menu_default', nor are prerequisites or exclusions mentioned. The description only states what the tool does, not when it should be selected.
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 mentions 'push' (implying a write operation) but doesn't specify permissions required, rate limits, error conditions, or what happens if the user ID is invalid. For a tool that sends messages and uses external AI, this is a significant gap in transparency about its operational 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, efficient sentence that front-loads the core functionality. It wastes no words and directly communicates the tool's purpose without redundancy, 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete for a tool that performs two complex actions (AI generation and messaging). It lacks details on error handling, response format, rate limits, or dependencies. For a 3-parameter tool with external integrations, this minimal description leaves too many operational questions unanswered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents parameters (userId, prompt, model). The description adds no additional semantic context beyond implying the prompt goes to Gemini and the message is sent to LINE. This meets the baseline of 3 since the schema does the heavy lifting, but the description doesn't enhance understanding of parameter roles or interactions.
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 ('Generate text with Gemini and push it to a LINE user as a text message'), specifying both the AI generation and messaging components. It distinguishes from siblings like 'push_text_message' (which lacks Gemini) and 'push_gemini_flex' (which uses Flex messages), though it doesn't explicitly name these alternatives. The purpose is specific but could be more precise about differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'push_text_message' (for non-Gemini text) or 'push_gemini_flex' (for rich messages). It implies usage for Gemini-generated text to LINE users, but lacks explicit when/when-not rules or prerequisites, leaving the agent to infer context from sibling names 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 full burden. It mentions 'push' messages but doesn't disclose behavioral traits like whether this requires specific permissions, rate limits, error handling, or what happens on success/failure. For a messaging tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded, with zero wasted content.
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 complexity of a messaging tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'push' entails operationally, return values, error conditions, or how it differs from sibling tools, leaving critical gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional meaning about parameters beyond what's in the schema, such as explaining the 'generic' aspect or providing examples. Baseline 3 is appropriate when the schema does the heavy lifting.
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 ('push') and resource ('LINE messages to a user'), making the purpose understandable. However, it doesn't differentiate this 'generic' tool from its more specific siblings like push_text_message or push_flex_message, which would require a 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. With siblings like push_text_message and push_flex_message available, there's no indication whether this tool is preferred for mixed message types or other scenarios, leaving usage unclear.
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 the tool performs a 'set' action, implying mutation, but does not cover permissions needed, whether the change is reversible, error conditions, or what happens to the previous default. This leaves significant gaps 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and appropriately sized for a simple tool, with no wasted information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects like side effects, return values, or error handling, which are critical for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with 'richMenuId' clearly documented. The description does not add any additional meaning beyond the schema, such as format examples or constraints, so it meets the baseline score for high schema coverage without compensating value.
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 ('set') and the resource ('rich menu as the default rich menu'), making the purpose immediately understandable. However, it does not differentiate from sibling tools like 'cancel_rich_menu_default' or explain what 'default' means in this context, 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?
No guidance is provided on when to use this tool versus alternatives like 'cancel_rich_menu_default' or 'get_rich_menu_list', nor are prerequisites or context for setting a default rich menu mentioned. The description lacks any usage instructions or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but provides minimal behavioral information. It mentions 'plan and execute' which suggests multi-step processing, but doesn't disclose execution characteristics like error handling, rate limits, authentication requirements, or what constitutes a 'LINE action.' The description is too vague about the tool's actual behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. However, it could be more structured by separating planning from execution aspects, and the parenthetical list of actions is somewhat cluttered. Overall, it's appropriately concise for the tool's complexity.
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 complex 9-parameter tool with no annotations and no output schema, the description is inadequate. It doesn't explain the relationship between Gemini planning and LINE execution, doesn't describe output format, and provides minimal context about how this tool differs from the many sibling LINE tools. The description leaves too many questions unanswered for proper agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 9 parameters thoroughly. The description doesn't add any meaningful parameter semantics beyond what's in the schema - it doesn't explain how parameters interact or provide usage examples beyond the single 'instruction' example. Baseline 3 is appropriate when schema does the heavy lifting.
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: 'Use Gemini to plan and execute one LINE action' with specific examples of actions (get profile, get rich menu list, etc.). It distinguishes from some siblings by mentioning Gemini integration, but doesn't explicitly differentiate from all similar LINE action tools like push_text_message or get_profile.
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 this tool should be used for LINE actions that require Gemini planning/execution, but doesn't provide explicit guidance on when to choose this versus direct action tools like push_text_message or get_profile. No 'when-not-to-use' criteria or clear alternatives are specified.
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. 'Cancel' implies a mutation operation, but the description doesn't specify whether this requires special permissions, what happens after cancellation (e.g., does it revert to a previous state?), or potential side effects. 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a simple tool and front-loads the essential information without unnecessary elaboration.
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 mutation tool with no annotations and no output schema, the description is minimally adequate but incomplete. It states what the tool does but lacks behavioral context (permissions, effects, return values) that would be helpful given the tool's complexity as a system configuration change.
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 doesn't discuss parameters, earning a baseline score of 4 for this zero-parameter tool.
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 ('cancel') and target resource ('default rich menu'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'delete_rich_menu' or 'set_rich_menu_default', which would require explicit comparison to achieve 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 like 'set_rich_menu_default' or 'delete_rich_menu'. There's 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions retrieving a list but doesn't specify whether this is a read-only operation, if authentication is required, potential rate limits, or the format of the returned data. This leaves significant gaps for an agent to understand the tool's 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 efficiently conveys the core functionality without any redundant information. It is appropriately sized and front-loaded, 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), the description adequately covers the basic purpose. However, without annotations or output schema, it lacks details on behavioral aspects like authentication needs or return format, which could be important for an agent to use it correctly in context.
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 doesn't discuss parameters, focusing instead on the tool's purpose. A baseline of 4 is applied since no parameters exist to document.
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 ('Get the list') and resource ('rich menus associated with your LINE Official Account'), providing a specific purpose. However, it doesn't explicitly differentiate from sibling tools like 'get_profile' or 'get_message_quota', 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 like 'set_rich_menu_default' or 'delete_rich_menu', nor does it mention prerequisites or context for usage. It simply states what the tool does without indicating appropriate scenarios.
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 but lacks critical behavioral details. It doesn't disclose whether this requires specific permissions, rate limits, delivery guarantees, error conditions, or what happens if the user ID is invalid. The description mentions customization but doesn't explain constraints 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?
Two sentences that are front-loaded with the core purpose and efficiently detail the supported layouts. Every word contributes to understanding the tool's functionality without redundancy or unnecessary elaboration.
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 (pushing messages) with no annotations, no output schema, and incomplete parameter documentation, the description is inadequate. It doesn't address behavioral aspects like authentication needs, error handling, or response format, leaving significant gaps for an AI agent to use it correctly.
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 50% (only 'message.contents.type' has a description). The description adds value by explaining bubble vs. carousel layouts, which clarifies the enum values, but doesn't cover other parameters like userId or altText. It partially compensates for the schema gap but leaves key parameters undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Push'), resource ('flex message'), target ('to a user via LINE'), and key capabilities ('highly customizable', 'supports both bubble and carousel layouts'). It distinguishes from sibling tools like push_text_message by specifying the message type.
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 like push_text_message, push_gemini_flex, or broadcast_flex_message. The description implies usage for flex messages but doesn't provide context about prerequisites, limitations, or comparison with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It mentions the action ('push') but lacks critical behavioral details: no information about authentication requirements, rate limits, error conditions, whether this is synchronous/asynchronous, or what happens on success/failure. The description is minimal and doesn't adequately disclose 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise: two sentences that directly state the tool's purpose and usage guidance. Every word earns its place with zero waste or redundancy.
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 message-sending tool with no annotations and no output schema, the description is insufficient. It doesn't cover important contextual aspects like response format, error handling, authentication needs, or rate limits. The description is too minimal given the tool's complexity and lack of structured metadata.
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 50% (userId has description, message.text has description, but message.type lacks description). The description adds no parameter-specific information beyond what's in the schema. With partial schema coverage, the description doesn't compensate for gaps, resulting in a baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('push a simple text message') and resource ('to a user via LINE'), with the specific constraint 'without formatting'. It distinguishes from formatting-rich siblings like push_flex_message but doesn't explicitly differentiate from push_text_message (if it exists) or push_messages.
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 implied usage guidance: 'Use this for sending plain text messages without formatting.' This suggests when to use it (plain text) but doesn't explicitly state when not to use it or name alternatives like push_flex_message or push_messages from the sibling list.
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 implies a read-only operation but does not specify authentication requirements, rate limits, error conditions, or response format details. For a tool with zero annotation coverage, 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 a single, efficient sentence that front-loads the core purpose and lists key return fields without unnecessary elaboration. Every word contributes directly to understanding the tool's function, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema) and high schema coverage, the description is adequate but incomplete. It lacks behavioral details (e.g., authentication, errors) that are crucial for a tool with no annotations, though the purpose and parameters are clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents the single parameter (userId). The description adds no additional parameter semantics beyond what the schema provides, such as format constraints or usage examples, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get detailed profile information') and resource ('LINE user'), listing the exact data fields returned (display name, profile picture URL, status message, language). It distinguishes this from sibling tools that focus on messaging, database queries, or rich menus, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., user ID availability), exclusions, or related tools for similar purposes, leaving the agent to infer usage context solely from the tool name and description.
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 discloses the broadcast nature ('sent to all users') which is crucial behavioral context, but doesn't mention rate limits, authentication requirements, message delivery guarantees, or potential costs/quotas. For a broadcast tool with zero annotation coverage, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized (3 sentences) and front-loaded with the core purpose. Every sentence adds value: first states the action, second specifies text-only limitation, third warns about broadcast scope. No wasted words, though it could be slightly more structured.
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 broadcast tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't cover error conditions, response format, rate limits, or authentication requirements. The warning about 'sent to all users' is helpful but insufficient for safe operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds no parameter-specific information beyond what's implied by the tool name and purpose. The single parameter (message object with text field) is documented only in the schema. The description doesn't explain the message structure, text length constraints, or provide examples.
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 ('broadcast a simple text message via LINE'), the target resource ('all users who have followed your LINE Official Account'), and distinguishes it from siblings by specifying 'plain text messages without formatting' (unlike broadcast_flex_message or push_flex_message which likely involve formatting).
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 ('for sending plain text messages without formatting'), but doesn't explicitly state when NOT to use it or name specific alternatives (like push_text_message for targeted messages vs broadcast). It implies this is for mass communication to all followers.
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. While 'Export' implies a read operation, it doesn't specify whether this requires database credentials, what happens if limits are exceeded, whether the operation is idempotent, or what happens if the output path already exists. The description lacks critical behavioral context for a tool that interacts with a database system.
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 communicates the core purpose without unnecessary words. It's front-loaded with the essential information and contains zero redundant or verbose elements.
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 tool with 3 parameters, 100% schema coverage, but no annotations or output schema, the description provides basic purpose but lacks important context about behavioral characteristics, error handling, and practical usage considerations. It's minimally adequate but leaves significant gaps in understanding how the tool behaves in real scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, providing complete parameter documentation. The description adds no additional parameter semantics beyond what's already in the schema. The baseline score of 3 reflects adequate but minimal value addition from the description regarding parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Export'), target resource ('MSSQL schema (tables/columns)'), and output format ('Markdown knowledge file for Q/A'). It distinguishes from sibling tools like 'query_mssql' and 'ai_query_mssql' by focusing on documentation export rather than query execution.
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 documentation files from database schemas, but provides no explicit guidance on when to use this tool versus alternatives like querying tools. There's no mention of prerequisites, dependencies, or scenarios where this tool would be preferred over manual documentation methods.
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 but lacks behavioral details. It mentions generation and pushing but doesn't disclose error handling, rate limits, authentication needs, whether messages are queued or sent immediately, or what happens if generation fails. The description doesn't contradict annotations (none exist), but provides minimal behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the core functionality: generation using Gemini from natural language, then pushing to a user. Every word earns its place with zero waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter tool with no annotations and no output schema, the description is minimally complete. It covers the what (generate+push) but lacks details about behavioral aspects, error cases, or output format. Given the complexity of a two-step operation (Gemini generation + LINE push), more context about how these integrate would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., doesn't explain prompt formatting best practices, model selection implications, or altText usage scenarios). Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Generate' and 'push') and resources ('LINE Flex message' and 'user'), distinguishing it from siblings like push_gemini_text (text only) and push_flex_message (no Gemini generation). It explicitly mentions using Gemini for generation from natural language, which is unique among push tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (when you want to generate and push a Flex message using Gemini), but doesn't explicitly state when to use this vs alternatives like push_flex_message (manual Flex creation) or push_gemini_text (text-only Gemini output). No exclusions or prerequisites 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?
With no annotations provided, the description carries full burden. It discloses the broadcast nature ('sent to all users') and mentions support for bubble/carousel layouts, but lacks details about permissions, rate limits, confirmation steps, or what happens on failure. The warning about broadcasting is helpful but incomplete for behavioral 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?
Two sentences with zero waste. First sentence establishes purpose and capabilities, second provides crucial behavioral warning. Every word earns its place, and the most important information (broadcast nature) is appropriately 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?
For a broadcast tool with no annotations, no output schema, and complex nested parameters, the description is moderately complete. It covers the broadcast scope and basic layout options but misses details about authentication requirements, error handling, response format, and the full complexity of the flex message structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions bubble/carousel layouts which correspond to the 'type' enum in the nested schema, but doesn't explain the 'altText' parameter or the complex 'contents' structure beyond basic layout types. This leaves significant gaps in 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 specific action ('broadcast'), resource ('flex message'), and platform ('LINE to all users who have added your LINE Official Account'). It distinguishes from siblings like 'broadcast_text_message' by specifying the message type and from 'push_flex_message' by indicating broadcast vs targeted push.
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: for sending flex messages to all LINE Official Account users. It implicitly distinguishes from sibling tools like 'broadcast_text_message' (text vs flex) and 'push_flex_message' (broadcast vs targeted), though it doesn't explicitly name alternatives or state 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?
With no annotations provided, the description carries the full burden. It clearly indicates this is a read-only operation ('Get') and specifies the data returned (quota and consumption), but does not disclose behavioral traits like rate limits, authentication needs, error conditions, or data freshness. It adds basic context but lacks operational 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 two concise sentences with zero waste: the first states the purpose, and the second elaborates on the returned data. It is front-loaded and every sentence adds value without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose and output semantics, but lacks context on usage scenarios, error handling, or integration with sibling tools, leaving gaps for an agent to infer operational 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 tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, maintaining focus on the tool's purpose. A baseline of 4 is applied as it efficiently handles the parameter-free case.
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 ('Get') and resource ('message quota and consumption of the LINE Official Account'), with explicit details about what information is retrieved ('monthly message limit and current usage'). It distinguishes itself from sibling tools that focus on messaging, broadcasting, or database 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 for monitoring message usage on LINE Official Accounts, but provides no explicit guidance on when to use this tool versus alternatives (e.g., for checking limits before sending messages) or any exclusions. It lacks named alternatives or contextual boundaries.
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 does well by stating the tool is 'read-only' and describing the return format (columns, rowCount, sliced rows for preview), but lacks details on error handling, performance characteristics, or authentication requirements. It provides some context but leaves gaps for a database query 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 extremely concise and front-loaded, consisting of a single sentence that efficiently communicates the tool's purpose, constraints, and output. Every word earns its place with no wasted information, 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 complexity (database queries with 4 parameters) and no output schema, the description is moderately complete. It covers the basic operation and output format but lacks details on error cases, result limitations, or connection specifics. With no annotations and no output schema, it should do more to guide usage fully.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain SQL syntax or parameter binding further). Baseline score of 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('run a read-only MSSQL query') and resource ('MSSQL'), and distinguishes it from siblings by specifying it handles SELECT/WITH queries only. It explicitly mentions what it returns (columns, rowCount, sliced rows), making its function unambiguous.
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 (for read-only SELECT/WITH queries) and implies when not to use it (for non-read-only operations), but does not explicitly name alternatives or provide detailed exclusions. It gives basic guidance without being comprehensive about sibling tools.
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 and does well by disclosing key behavioral traits: it's safe and read-only, uses Gemini for query generation, includes validation, executes the query, and returns rows. However, it lacks details on error handling, rate limits, or specific validation rules, leaving some gaps in behavioral context.
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 highly concise and front-loaded in a single sentence that efficiently covers purpose, process, and constraints. Every word earns its place, with no redundant or vague phrasing, making it easy to parse quickly.
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 complexity (natural language to SQL conversion with safety validation) and lack of annotations and output schema, the description is reasonably complete. It covers the core functionality and safety aspects but could benefit from mentioning output format or error cases. However, it adequately addresses the main use case without being overly verbose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minimal semantic value beyond the schema, only implying that 'instruction' is natural language and the tool is read-only. It doesn't provide additional context on parameter interactions or usage examples, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('generate', 'validate', 'execute', 'return') and resource ('MSSQL SELECT'), and distinguishes it from sibling 'query_mssql' by emphasizing safe read-only operation via Gemini. It explicitly mentions the natural language input and the read-only constraint.
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 usage guidance: it specifies when to use this tool (for safe read-only queries from natural language instructions via Gemini) and implicitly when not to use it (for non-SELECT operations or direct SQL execution, as suggested by the sibling 'query_mssql'). It clearly differentiates from alternatives by highlighting the Gemini-mediated approach.
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_management MCP server](https://glama.ai/mcp/servers/tndfame/mcp_management/badges/card.svg)](https://glama.ai/mcp/servers/tndfame/mcp_management)

Score Badge

Copy to your README.md:

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

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/tndfame/mcp_management'

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