Haloscan MCP Server
Integrates keyword research, domain performance metrics, and competitive SEO analysis into automated workflows via the Haloscan API.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Haloscan MCP ServerGive me an SEO overview for the keyword 'sustainable fashion'."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Haloscan MCP Server
A Model Context Protocol (MCP) server for interacting with the Haloscan SEO API.
This server allows easy integration with Claude for Desktop, N8N, and other MCP-compatible clients.
Features
Exposes Haloscan SEO API functionality through MCP tools
Provides prompts for common SEO tasks
Easy integration with workflow automation tools like N8N
Related MCP server: Haloscan MCP Server
Tools
1. User Tools
get_user_credit
Retrieves the remaining credit for the user identified by the provided API key.
2. Keyword Explorer Tools
get_keywords_overview
Retrieves an overview of a specific keyword, providing key performance indicators such as search volume, competition level, and trends over time.
Inputs:
keyword(string): Requested keyword.requested_data(string[]): Any combination of [keyword_match, related_search, related_question, similar_category, similar_serp, top_sites, similar_highlight, categories, synonyms, metrics, volume_history, serp ].
get_keywords_match
Retrieves keyword data based on an exact match search, providing detailed insights into how the specific keyword performs in search engines.
Input:
keyword(string): Requested keyword.
get_keywords_similar
Retrieves the list of keywords that are semantically or topically similar to a given keyword.
Input:
keyword(string): Requested keyword.
get_keywords_highlights
Retrieves the key performance highlights from a given keyword.
Input:
keyword(string): Requested keyword.
get_keywords_related
Retrieves the list of keywords that are contextually or topically related to a given keyword.
Input:
keyword(string): Requested keyword.
get_keywords_questions
Retrieves a list of question-based keywords related to a given keyword.
Input:
keyword(string): Requested keyword.
get_keywords_synonyms
Retrieves a list of synonyms related to a given keyword.
Input:
keyword(string): Requested keyword.
get_keywords_find
Retrieves comprehensive data for a given keyword or list of keywords, including search volume, competition, and trend analysis.
Inputs:
keyword(string): Requested keyword.keywords(string[]): Requested keywords.keywords_sources(string[]): Which strategies to use to find keywords from input (Any combination of [match, serp, related, highlights, categories, questions]).
get_keywords_site_structure
Retrieves the site structure data for a given domain, including the keywords associated with the site's pages, hierarchical organization, and relevant metadata for SEO optimization.
Input:
keyword(string): Requested keyword.
get_keywords_serp_compare
Retrieves a comparison of search engine results pages (SERP) for two or more keywords, providing insights into how they perform in search rankings.
Inputs:
keyword(string): Requested keyword.period(string): The comparison period for SERPs (1 month, 3 months, 6 months, 12 months, custom).
get_keywords_serp_availableDates
Retrieves the available dates for historical SERP data of a given keyword at a given period.
Input:
keyword(string): Requested keyword.
get_keywords_serp_pageEvolution
Retrieves the evolution of SERP rankings for a specific keyword over time, showing how a page's position in search results has changed.
Inputs:
keyword(string): Requested keyword.first_date(string): Date in YYYY-MM-DD format.second_date(string): Date in YYYY-MM-DD format.url(string)
get_keywords_bulk
Retrieves keyword data for multiple keywords at once in a bulk request.
Input:
keywords(string[]): Array containing the requested keywords.
get_keywords_scrap
Retrieves keyword data by scraping the search engine results pages (SERP) for a given keyword.
Input:
keywords(string[]): Array containing the requested keywords.
3. Site Explorer Tools
get_domains_overview
Retrieves a comprehensive SEO performance summary for a specific domain.
Inputs:
input(string): Requested url, domain or root domain.requested_data(string[]): Requested data for the given url or domain, corresponding to the content of different sections of the haloscan overview page.
get_domains_positions
Retrieves the search engine ranking positions of a specified domain for one or more keywords.
Input:
input(string): Requested url, domain or root domain.
get_domains_top_pages
Retrieves the top-performing pages of a specified domain based on organic search metrics such as traffic, number of ranking keywords, and visibility.
Input:
input(string): Requested url, domain or root domain.
get_domains_history_positions
Retrieves historical ranking positions for a specific domain across selected keywords.
Inputs:
input(string): Requested url or domain.date_from(string): Date in YYYY-MM-DD format.date_to(string): Date in YYYY-MM-DD format.
get_domains_history_pages
Retrieves historical SEO performance data for the top pages of a specified domain.
Inputs:
input(string): Requested url or domain.date_from(string): Date in YYYY-MM-DD format.date_to(string): Date in YYYY-MM-DD format.
get_page_best_keywords
Retrieves the top-performing keywords for a specific URL, showing which search queries drive the most traffic and visibility to that page.
Input:
input(string[]): Requested urls.
get_domains_keywords
Retrieves all the keywords a domain ranks for in organic search results, along with their associated metrics such as ranking position, traffic, and search volume.
Inputs:
input(string): Requested url or domain.keywords(string[]): Array containing the requested keywords.
get_domains_bulk
Retrieves SEO performance metrics for multiple domains in a single request.
Input:
inputs(string[]): Array containing the requested urls or domains.
get_domains_competitors
Retrieves a list of organic search competitors for a given domain based on overlapping keywords.
Input:
input(string): Requested url or domain.
get_domains_competitors_keywords_diff
Compares the keyword differences between a given domain and its competitors, highlighting keywords that one domain ranks for but the other does not.
Inputs:
input(string): Requested url or domain.competitors(string[]): List of competitors to compare the input to.
get_domains_competitors_best_pages
Retrieves the best-performing pages of competitors for a given domain.
Inputs:
input(string): Requested url or domain.competitors(string[]): List of competitors to compare the input to.
get_domains_competitors_keywords_best_positions
Retrieves the best-ranking keywords for a given domain compared to its competitors.
Inputs:
competitors(string[]): List of competitor domains or root domains.keywords(string[]): List of keywords to look for.
get_domains_visibility_trends
Retrieves the visibility trend for a specific domain over time, showing how its search engine visibility has evolved.
Input:
input(string[]): Array containing the requested urls or domains.
get_domains_expired
Retrieves the visibility trend for a specific domain over time, showing how its search engine visibility has evolved.
Configuration
Sign up for an Haloscan account.
Choose a plan.
Generate your API key from Configuration API page.
Use the API key for the Haloscan server in the Claude Desktop configuration file.
Usage with Claude Desktop
Add this server to your Claude Desktop configuration file claude_desktop_config.json:
NPX
{
"mcpServers": {
"haloscan": {
"command": "npx",
"args": [
"-y",
"@occirank/haloscan-server",
"start"
],
"env": {
"HALOSCAN_API_KEY": "YOUR API KEY"
}
}
}
}License
MIT
Available Tools
33 toolsget_domains_bulkD
Obtenir des domaines en masse.
| Name | Required | Description | Default |
|---|---|---|---|
| inputs | Yes | Specific data fields to request |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden but discloses nothing about behavior. It doesn't mention if this is a read-only operation, what permissions are needed, rate limits, pagination, or what the output format looks like. This leaves critical behavioral traits unknown.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single phrase that is under-specified rather than concise. It lacks front-loading of key details and wastes the opportunity to provide essential context, making it inefficient despite its brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by sibling tools and lack of annotations or output schema, the description is severely incomplete. It doesn't explain what 'domains' means, what data is returned, or how bulk retrieval works, failing to compensate for missing structured information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the 'inputs' parameter documented as 'Specific data fields to request'. The description adds no additional meaning beyond this, such as examples of valid fields or formatting. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir des domaines en masse' (Get domains in bulk) states a vague purpose without specifying what kind of domains or what data about them is retrieved. It doesn't distinguish from siblings like 'get_domains_overview' or 'get_domains_expired', leaving the agent uncertain about the exact resource scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools like 'get_domains_overview' or 'get_domains_keywords', the description offers no context, prerequisites, or exclusions, making it impossible for an agent to choose appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_competitorsC
Obtenir les concurrents des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword |
TDQS
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. The description only states what the tool does ('get competitors'), with no information about permissions, rate limits, data format, pagination, or error handling. For a tool with no 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's function. There's no wasted verbiage or unnecessary elaboration, making it appropriately concise and front-loaded for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of competitor analysis tools and the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'competitors' means in this context, what data is returned, or how the tool behaves. For a tool with no structured metadata, the description should provide more context to be useful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage (the 'input' parameter is documented as 'Seed keyword'), so the baseline score is 3. The description adds no additional parameter semantics beyond what the schema provides—it doesn't clarify what a 'seed keyword' means in this context or provide examples of valid inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the purpose ('Obtenir les concurrents des domaines' translates to 'Get competitors of domains'), which is a clear verb+resource combination. However, it doesn't differentiate from sibling tools like 'get_domains_competitors_best_pages' or 'get_domains_competitors_keywords_diff', leaving the specific scope ambiguous. The description is functional but lacks precision about what type of competitor data is returned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 multiple sibling tools containing 'competitors' in their names (e.g., 'get_domains_competitors_best_pages'), there's no indication of how this tool differs or when it's the appropriate choice. The agent must infer usage from the tool name alone, which is insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_competitors_best_pagesC
Obtenir les meilleures pages des concurrents des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword | |
| competitors | Yes | Specific data fields to request |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. The description fails to explain what 'best pages' means (e.g., by traffic, relevance, or other metrics), whether this is a read-only operation, if it requires authentication, or any rate limits. It lacks essential context about the tool's behavior and output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, with no wasted words. It is appropriately sized for a simple tool, though it could be more informative. The structure is straightforward, but it lacks front-loading of critical details like purpose differentiation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by sibling tools and the lack of annotations and output schema, the description is incomplete. It does not clarify the tool's role among similar tools, explain behavioral traits, or detail what 'best pages' means. For a tool with two parameters and no structured output information, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for both parameters: 'input' as 'Seed keyword' and 'competitors' as 'Specific data fields to request.' The description adds no additional meaning beyond the schema, such as explaining how 'competitors' relates to domains or what 'best pages' entails. However, with high schema coverage, a baseline score of 3 is appropriate as the schema adequately documents parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les meilleures pages des concurrents des domaines' is a tautology that essentially restates the tool name in French. It translates to 'Get the best pages of domain competitors,' which mirrors the English name 'get_domains_competitors_best_pages' without adding specificity or distinguishing it from sibling tools like 'get_domains_competitors' or 'get_domains_top_pages.' No clear verb-resource distinction or unique purpose is articulated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 multiple sibling tools related to domains, competitors, and pages (e.g., 'get_domains_competitors', 'get_domains_top_pages'), there is no indication of context, prerequisites, or exclusions. This leaves the agent without direction for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_competitors_keywords_diffC
Obtenir la différence de mots-clés entre les domaines et leurs concurrents.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword | |
| competitors | Yes | Specific data fields to request |
TDQS
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 describes a read operation ('obtenir') but doesn't cover critical aspects like rate limits, authentication needs, data freshness, or what the output looks like (since no output schema exists). For a tool with two required parameters and no annotations, this leaves the agent guessing about behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French. It's front-loaded with the core purpose and wastes no words. However, it could be more structured by explicitly stating the tool's scope or output, but given its brevity, it earns a high score for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (comparing domains and competitors for keyword differences), lack of annotations, no output schema, and vague purpose, the description is incomplete. It doesn't explain what 'domaines' are, how the difference is calculated, or what the result includes. For a tool with two required parameters and no structured output, more context is needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters documented: 'input' as 'Seed keyword' and 'competitors' as 'Specific data fields to request'. The description adds no additional meaning beyond the schema—it doesn't clarify what 'domaines' are, how competitors relate to them, or the format of the keyword difference. With high schema coverage, the baseline is 3, but the description doesn't compensate for potential ambiguities.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose in French: 'Obtenir la différence de mots-clés entre les domaines et leurs concurrents' (Get the keyword difference between domains and their competitors). It specifies a verb ('obtenir') and resource ('différence de mots-clés'), but it's vague about what 'domaines' refers to and doesn't clearly differentiate from sibling tools like get_domains_competitors or get_domains_keywords. The purpose is understandable but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, context, or exclusions. Given many sibling tools (e.g., get_domains_competitors, get_domains_keywords), the agent must infer usage without help. This is a significant gap for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_expiredC
Obtenir les domaines expirés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | No | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It implies a read operation ('get') but lacks details on permissions, rate limits, output format, or behavioral traits. The description is too vague to adequately inform the agent beyond basic intent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French ('Obtenir les domaines expirés.'), which is appropriately sized and front-loaded with no wasted words, earning full marks for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 simple input schema, the description is incomplete. It fails to explain what 'expired domains' entails, how results are returned, or usage context, making it inadequate for a tool with many siblings and potential complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with one parameter ('keyword') documented as 'Seed keyword'. The description adds no parameter details beyond the schema, 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les domaines expirés' (Get expired domains) restates the tool name 'get_domains_expired' with minimal elaboration, making it tautological. It specifies the resource (expired domains) but lacks a clear verb beyond 'get' and doesn't differentiate from siblings like 'get_domains_expired_reveal'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools (e.g., 'get_domains_bulk', 'get_domains_expired_reveal'), the description offers no context, exclusions, or prerequisites, leaving the agent without direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_expired_revealC
Révéler les domaines expirés.
| Name | Required | Description | Default |
|---|---|---|---|
| root_domain_keys | Yes | Seed keyword |
TDQS
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 mentions 'reveal' but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires authentication, rate limits, or what the output format might be. The description is too minimal to inform the agent adequately about 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence in French, front-loaded with the core action. It's appropriately sized for a simple tool, with no wasted words, though it could benefit from more detail to improve clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 single parameter with full schema coverage, the description is incomplete. It fails to explain what 'reveal' means operationally, what the tool returns, or how it differs from similar tools, leaving significant gaps for the agent to understand its use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'root_domain_keys' documented as 'Seed keyword'. The description adds no additional meaning beyond the schema, such as explaining what 'root_domain_keys' represents or how it affects the reveal process. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Révéler les domaines expirés' (Reveal expired domains) states a clear verb ('révéler') and resource ('domaines expirés'), but it's vague about what 'reveal' entails—whether it lists, filters, or provides details. It distinguishes from siblings like 'get_domains_expired' by implying a reveal action, but the distinction is subtle and not well-specified.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With siblings like 'get_domains_expired' and 'get_domains_bulk', the description lacks context on use cases, prerequisites, or exclusions, leaving the agent to guess based on the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_gmb_backlinksC
Obtenir les backlinks des domaines GMB.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword |
TDQS
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 mentions retrieving backlinks but doesn't disclose behavioral traits such as rate limits, authentication needs, data format, pagination, or whether it's read-only or destructive. For a tool with no annotations, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, with no wasted words. It's appropriately sized and front-loaded, though it could be more informative without sacrificing brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 single parameter with full schema coverage, the description is incomplete. It doesn't explain what 'GMB' means, the return format, or how it differs from siblings, making it inadequate for a tool in a complex domain with many alternatives.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'input' described as 'Seed keyword'. The description doesn't add any meaning beyond this, so it meets the baseline of 3 where the schema does the heavy lifting, but doesn't compensate or provide extra context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les backlinks des domaines GMB' (Get backlinks from GMB domains) states a clear verb ('Obtenir') and resource ('backlinks des domaines GMB'), but it's vague about what 'GMB' refers to (likely Google My Business) and doesn't distinguish it from sibling tools like 'get_domains_gmb_backlinks_categories' or 'get_domains_gmb_backlinks_map'. It provides a basic purpose but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools (e.g., 'get_domains_gmb_backlinks_categories', 'get_domains_gmb_backlinks_map'), the description doesn't explain differences, prerequisites, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_gmb_backlinks_categoriesC
Obtenir les catégories des backlinks des domaines GMB.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. The description only states what the tool does at a high level without disclosing behavioral traits like whether this is a read-only operation, what format the categories are returned in, whether there are rate limits, or what authentication is required. For a tool with no annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point. There's no wasted verbiage or unnecessary elaboration. However, the language mismatch between French description and English tool name slightly detracts from clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is inadequate. It doesn't explain what 'categories' means in this context, what format the results will be in, or how the seed keyword relates to GMB domains. Given the complexity implied by the tool name and the lack of structured documentation, the description should provide more context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with the single parameter 'input' described as 'Seed keyword.' The description adds no additional parameter information beyond what's in the schema. With complete schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting for parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose as 'Obtenir les catégories des backlinks des domaines GMB' (Get categories of backlinks from GMB domains), which is a clear verb+resource combination. However, it's in French while the tool name is in English, creating potential confusion, and it doesn't differentiate from sibling tools like 'get_domains_gmb_backlinks' or 'get_domains_gmb_backlinks_map' that also deal with GMB backlinks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 multiple sibling tools dealing with domains and GMB backlinks, there's no indication of what makes this tool distinct or when it's the appropriate choice compared to similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_gmb_backlinks_mapC
Obtenir la carte des backlinks des domaines GMB.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'obtenir' (get), implying a read-only operation, but doesn't specify whether it's a simple retrieval, a complex analysis, or if it involves API rate limits, authentication needs, or data freshness. For a tool with no annotation coverage, this lack of behavioral context 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, with no wasted words. It's front-loaded with the core action and resource. However, the brevity comes at the cost of clarity, as it lacks necessary details for a tool with no annotations or output schema, slightly reducing its effectiveness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by 'map' and the lack of annotations and output schema, the description is incomplete. It doesn't explain what the output looks like (e.g., a visual map, JSON data), how the backlinks are analyzed, or any prerequisites. For a tool with one parameter but potentially rich behavior, this minimal description leaves too many gaps for the agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'input' documented as 'Seed keyword'. The description adds no additional meaning beyond this—it doesn't clarify what a 'seed keyword' is in the context of GMB backlinks maps or provide examples. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, but the description fails to enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir la carte des backlinks des domaines GMB' (Get the backlinks map of GMB domains) states a clear action ('obtenir') and resource ('carte des backlinks des domaines GMB'), but it's vague about what 'carte' (map) specifically means—is it a visualization, a list, or a structured report? It distinguishes from siblings like 'get_domains_gmb_backlinks' by specifying 'map', but the distinction isn't clearly explained, leaving the purpose somewhat ambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'get_domains_gmb_backlinks' and 'get_domains_gmb_backlinks_categories', there's no indication of differences in scope, output format, or use cases. The agent must infer usage from tool names alone, which is insufficient for effective selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_history_pagesC
Obtenir l’historique des pages des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword | |
| date_from | Yes | Seed keyword | |
| date_to | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It only states the action ('Obtenir') without details on permissions, rate limits, output format, or side effects. For a tool with 3 required parameters and no output schema, this leaves critical gaps in understanding how it behaves and what to expect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence in French, front-loaded with the core action. It avoids redundancy but is overly brief, potentially sacrificing clarity for brevity in a multilingual context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 required parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, usage context, and output expectations, making it insufficient for an AI agent to reliably invoke the tool without additional assumptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters documented in the schema (input, date_from, date_to as 'Seed keyword'). The description adds no additional meaning beyond the schema, such as clarifying parameter roles or formats. Baseline 3 is appropriate as the schema handles parameter documentation adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose in French ('Obtenir l’historique des pages des domaines' translates to 'Get the history of domain pages'), which provides a basic verb+resource combination. However, it's vague about what 'history of domain pages' entails and doesn't differentiate from sibling tools like 'get_domains_history_positions' or 'get_domains_top_pages', leaving ambiguity about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With multiple sibling tools focused on domains (e.g., 'get_domains_history_positions', 'get_domains_top_pages'), the description lacks context for selection, prerequisites, or exclusions, offering only a basic statement of function.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_history_positionsC
Obtenir l’historique des positions des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword | |
| date_from | Yes | Seed keyword | |
| date_to | Yes | Seed keyword |
TDQS
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 only states the action ('obtenir') without any details on permissions, rate limits, data format, pagination, or what 'historique des positions' entails. This leaves the agent with insufficient information to understand the tool's behavior beyond a basic read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's purpose without unnecessary words. It is 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a tool with 3 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, usage context, and output format, which are critical for an agent to use this tool effectively. The high schema coverage helps with parameters, but overall context is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with all three parameters ('input', 'date_from', 'date_to') documented as 'Seed keyword'. The description adds no additional meaning beyond this, such as clarifying the purpose of 'input' or date formats. With high schema coverage, the 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir l’historique des positions des domaines' (Get the history of domain positions) restates the tool name 'get_domains_history_positions' in French, making it essentially tautological. It specifies the verb 'obtenir' (get) and resource 'domaines' (domains) with 'historique des positions' (history of positions), but doesn't distinguish it from siblings like 'get_domains_positions' or 'get_domains_visibility_trends' which might provide related data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 any context, prerequisites, or exclusions, and with many sibling tools like 'get_domains_positions' and 'get_domains_visibility_trends', the lack of differentiation is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_keywordsC
Obtenir les mots-clés des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword | |
| keywords | Yes | Specific data fields to request |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states the action ('obtenir') without disclosing behavioral traits like whether it's a read-only operation, requires authentication, has rate limits, returns structured data, or involves pagination. For a tool with 2 required parameters and no output schema, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's purpose without unnecessary words. However, it could be more front-loaded with critical context given the lack of annotations and many sibling tools, making it slightly under-specified rather than optimally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 required parameters, no output schema, no annotations, and many sibling tools), the description is incomplete. It doesn't explain return values, usage context, or behavioral aspects, leaving the agent with insufficient information to use the tool effectively beyond basic parameter input.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters ('input' as 'Seed keyword' and 'keywords' as 'Specific data fields to request') well-documented in the schema. The description adds no additional meaning about parameters beyond what the schema provides, so it meets the baseline of 3 when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les mots-clés des domaines' (Get domain keywords) states a clear verb ('obtenir' - get) and resource ('mots-clés des domaines' - domain keywords), but it's vague about scope and doesn't differentiate from siblings like 'get_domains_overview' or 'get_keywords_related'. It doesn't specify what kind of keywords or for what purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools like 'get_domains_overview', 'get_keywords_related', and 'get_keywords_find', the description offers no context about appropriate use cases, prerequisites, or distinctions from similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_overviewD
Obtenir un aperçu des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword | |
| requested_data | Yes | Specific data fields to request |
TDQS
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. The description reveals nothing about what the tool actually does beyond the vague 'overview' concept. It doesn't indicate whether this is a read-only operation, what data format is returned, whether there are rate limits, authentication requirements, or any other behavioral characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While technically concise (one short sentence), this is a case of under-specification rather than effective conciseness. The single sentence 'Obtenir un aperçu des domaines' fails to provide essential information that would help an AI agent use the tool correctly. Every sentence should earn its place, and this one doesn't earn enough.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by having 27 sibling tools and no output schema, this description is completely inadequate. The tool appears to be part of a sophisticated domain/keyword analysis system, but the description provides no context about what an 'overview' contains, how it differs from other domain tools, or what to expect in return. With no annotations and no output schema, the description fails to compensate for these gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 ('input' as seed keyword and 'requested_data' as specific data fields). The description adds no additional meaning about these parameters - it doesn't explain what kind of seed keyword is expected, what data fields are available, or how the parameters interact. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir un aperçu des domaines' (Get an overview of domains) is a tautology that essentially restates the tool name 'get_domains_overview' in French. It doesn't specify what 'overview' means or what kind of domain information is provided, nor does it distinguish this tool from its many siblings like 'get_domains_bulk', 'get_domains_keywords', or 'get_domains_positions'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides absolutely no guidance about when to use this tool versus alternatives. With 27 sibling tools including many other domain-related tools, there's no indication of what makes 'overview' different from 'bulk', 'keywords', 'positions', or other domain queries. No context, prerequisites, or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_positionsC
Obtenir les positions des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states the action without disclosing behavioral traits like whether it's read-only, requires authentication, has rate limits, returns paginated results, or what format the output takes. This is inadequate for a tool with no 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, front-loaded with the core purpose. However, it's under-specified rather than concise, as it lacks necessary details for clarity in a multi-tool context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 vague purpose amidst many siblings, the description is incomplete. It fails to compensate for missing structured data, leaving critical gaps in understanding the tool's behavior and output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with one parameter 'input' described as 'Seed keyword'. The description adds no meaning beyond this, as it doesn't explain how the seed keyword relates to domain positions or provide examples. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les positions des domaines' (Get domain positions) states the action (obtain) and resource (domain positions), but it's vague about what 'positions' means (e.g., search rankings, geographical locations, organizational roles). It doesn't distinguish from siblings like 'get_domains_history_positions' or 'get_domains_overview', leaving ambiguity in scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools (e.g., 'get_domains_competitors', 'get_domains_history_positions'), the description lacks context, prerequisites, or exclusions, leaving the agent to guess based on names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_top_pagesC
Obtenir les pages principales des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It doesn't disclose behavioral traits such as whether it's read-only, requires authentication, has rate limits, or what the output format looks like. The description only states what it does, not how it behaves, leaving significant gaps for an AI agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, front-loaded with the core action. There's no wasted text, making it appropriately sized for its minimal content. Every word earns its place, though this conciseness comes at the cost of detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 simple input schema, the description is incomplete. It doesn't explain what 'main pages' are, how results are returned, or any behavioral context. For a tool with one parameter but unclear output, more information is needed to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with a parameter 'input' described as 'Seed keyword'. The description adds no meaning beyond this, as it doesn't explain how the seed keyword relates to obtaining main pages. With high schema coverage, the baseline is 3, but the description doesn't compensate with additional context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les pages principales des domaines' (Get the main pages of domains) states a clear verb ('obtenir') and resource ('pages principales des domaines'), but it's vague about what 'main pages' means and doesn't distinguish from siblings like 'get_domains_overview' or 'get_domains_history_pages'. It provides a basic purpose but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools like 'get_domains_overview' or 'get_domains_history_pages', the description doesn't indicate context, exclusions, or prerequisites. Usage is implied only by the name, not explained.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_domains_visibility_trendsC
Obtenir les tendances de visibilité des domaines.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Specific data fields to request |
TDQS
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 only states what the tool does ('obtenir les tendances') without mentioning any behavioral traits such as whether it's a read-only operation, requires authentication, has rate limits, returns historical data, or involves pagination. For a tool with no annotations, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse. However, it could be slightly more informative without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by 'tendances' (trends) and the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., time-series data, metrics), how to interpret 'visibility', or any prerequisites. For a tool that likely involves data analysis over time, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with one parameter 'input' described as 'Specific data fields to request'. The description adds no additional meaning beyond this, as it doesn't explain what 'tendances de visibilité' entails or what fields might be relevant. With high schema coverage, the baseline score of 3 is appropriate, but the description doesn't compensate with extra context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les tendances de visibilité des domaines' (Get domain visibility trends) states a clear verb ('obtenir') and resource ('tendances de visibilité des domaines'), but it's vague about what 'visibility trends' specifically means. It doesn't distinguish this tool from siblings like 'get_domains_overview' or 'get_domains_history_positions', which might also provide visibility-related data. The purpose is understandable but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 many sibling tools related to domains (e.g., 'get_domains_overview', 'get_domains_history_positions'), there's no indication of what makes this tool unique or when it's preferred. Usage is implied only by the name, but no explicit context or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_bulkC
Obtenir des mots-clés en masse.
| Name | Required | Description | Default |
|---|---|---|---|
| keywords | Yes | Specific data fields to request |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden but offers minimal behavioral insight. It doesn't disclose if this is a read-only operation, requires authentication, has rate limits, or what the output entails (e.g., structured data, raw text). For a bulk operation with no annotations, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, with no wasted words. However, it's front-loaded with minimal detail, which under-specifies rather than being optimally concise. It earns a 4 for brevity but loses points for lacking essential context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 vague description, this is incomplete for a bulk operation tool. The agent lacks critical context: what the tool returns, behavioral traits, or how it differs from siblings. For a 1-param tool with 100% schema coverage, the description fails to compensate for other gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'keywords' documented as 'Specific data fields to request'. The description adds no additional meaning beyond this, such as clarifying the array's purpose (e.g., list of keyword terms to fetch data for) or usage examples. Baseline 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir des mots-clés en masse' (Get keywords in bulk) states a general action but lacks specificity. It doesn't clarify what 'mots-clés' refers to (e.g., SEO keywords, content tags) or what 'en masse' entails (e.g., batch retrieval, bulk processing). While it distinguishes from non-bulk siblings like 'get_keywords_find', it's too vague for precise understanding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With siblings like 'get_keywords_find', 'get_keywords_overview', and 'get_keywords_related', the description doesn't indicate context (e.g., use for batch keyword data vs. single searches) or exclusions. This leaves the agent guessing about appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_findC
Trouver des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | No | Seed keyword | |
| keywords | No | Seed keyword | |
| keywords_sources | No | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. 'Trouver des mots-clés' implies a read-only search operation but reveals nothing about rate limits, authentication needs, output format, pagination, or error conditions. For a tool with 3 parameters and no annotations, this is a critical 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—a single French phrase—and front-loaded with the core action. However, this brevity comes at the cost of under-specification; while structurally efficient, it lacks necessary detail for effective tool use.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of having 3 parameters, no annotations, no output schema, and many sibling tools, the description is incomplete. It fails to explain what the tool returns, how inputs interact, or behavioral traits, leaving significant gaps for an agent to operate effectively in this crowded toolset.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters documented as 'Seed keyword'. The description adds no meaning beyond the schema—it doesn't clarify the relationship between 'keyword' (singular) and 'keywords' (array), what 'keywords_sources' entails, or how these inputs affect the search. With high schema coverage, the baseline is 3, but no additional value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Trouver des mots-clés' (Find keywords) restates the tool name 'get_keywords_find' in French, making it essentially tautological. It lacks specificity about what kind of keywords are found, how they're found, or what distinguishes this from sibling tools like 'get_keywords_related', 'get_keywords_similar', or 'get_keywords_synonyms'. The purpose is vague without differentiation from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 the many sibling keyword tools (e.g., get_keywords_related, get_keywords_similar, get_keywords_bulk). The description offers no context, prerequisites, or exclusions, leaving the agent with no basis for selection among similar-sounding alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_highlightsD
Obtenir les points forts des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword |
TDQS
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. The description only states what the tool does at a superficial level ('get highlights') without explaining what 'highlights' entails, whether this is a read-only operation, if it has rate limits, authentication requirements, or what the output format might be. For a tool with zero annotation coverage, this is a significant gap in 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
While the description is technically concise (one short sentence), it suffers from under-specification rather than effective brevity. The single sentence doesn't earn its place by providing sufficient value - it's too vague to be genuinely helpful. This isn't true conciseness but rather inadequate content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there are no annotations and no output schema, the description should provide more complete context about what this tool does and returns. The tool has one parameter with good schema coverage, but the description fails to explain what 'highlights' means, what kind of data is returned, or how this differs from other keyword-related tools. For a tool in a crowded namespace with many siblings, this description is insufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'keyword' documented as 'Seed keyword'. The description doesn't add any meaningful information beyond what the schema already provides about parameters. According to the scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no parameter information in the description, which applies here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les points forts des mots-clés' (Get the highlights of keywords) is a tautology that essentially restates the tool name 'get_keywords_highlights' in French. It doesn't specify what 'highlights' means in this context or what resource is being accessed. While it mentions keywords, it lacks the specific verb+resource clarity needed to distinguish it from sibling tools like get_keywords_overview or get_keywords_related.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 many sibling tools focused on keywords (e.g., get_keywords_overview, get_keywords_related, get_keywords_questions), there's no indication of what makes this tool unique or when it should be selected over others. The description is completely silent on usage context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_matchC
Obtenir la correspondance des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It implies a read-only operation ('obtenir' - get) but doesn't disclose behavioral traits like rate limits, authentication needs, output format, pagination, or error handling. For a tool with no annotation coverage, this minimal description fails to provide essential context for safe and effective use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, with no wasted words. It's appropriately sized for a simple tool, though it could be more informative without sacrificing brevity. The structure is straightforward but lacks front-loading of critical details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 simple input schema, the description is incomplete. It doesn't explain what 'correspondance' means in terms of return values (e.g., list of matching keywords with metrics), behavioral constraints, or how it fits among sibling keyword tools. For a tool in a crowded namespace, more context is needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'keyword' documented as 'Seed keyword'. The description adds no additional meaning about the parameter (e.g., format examples, language constraints, or how it influences matches). With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir la correspondance des mots-clés' (Get keyword matches) restates the tool name 'get_keywords_match' with minimal elaboration. It specifies the action ('obtenir' - get) and resource ('correspondance des mots-clés' - keyword matches), but lacks specificity about what 'matches' entails (e.g., related keywords, search volume matches, competitor matches) and doesn't differentiate from sibling tools like 'get_keywords_related' or 'get_keywords_similar'. This is borderline tautological with only basic verb+resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. The description doesn't mention context, prerequisites, or exclusions. Given multiple sibling tools for keywords (e.g., 'get_keywords_related', 'get_keywords_similar', 'get_keywords_bulk'), the absence of usage guidelines leaves the agent guessing about appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_overviewD
Obtenir un aperçu des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword | |
| requested_data | Yes | Specific data fields to request |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It only states the purpose without mentioning if it's a read/write operation, authentication needs, rate limits, output format, or any side effects. This is inadequate for a tool with parameters and no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence, but it's under-specified rather than efficiently informative. It front-loads the purpose but lacks necessary details, making it too brief for effective tool selection.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 vague description, this is incomplete for a tool with 2 required parameters. The agent cannot infer behavior, output, or proper usage, especially with many sibling tools, making it inadequate for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters ('keyword' and 'requested_data') documented in the schema. The description adds no additional meaning beyond the schema, such as examples or constraints. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir un aperçu des mots-clés' (Get an overview of keywords) restates the tool name 'get_keywords_overview' almost verbatim, making it a tautology. It doesn't specify what 'aperçu' (overview) entails or what resource it operates on beyond 'keywords', nor does it differentiate from sibling tools like 'get_keywords_bulk', 'get_keywords_find', or 'get_keywords_related'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. With many sibling tools like 'get_keywords_bulk' and 'get_keywords_related', the description fails to provide any context, prerequisites, or exclusions, leaving the agent with no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_questionsC
Obtenir les questions liées aux mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword |
TDQS
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 only states the action without details on permissions, rate limits, output format, or error handling. For a tool with no annotations, this is insufficient to inform the agent about how it behaves beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, making it concise and front-loaded. However, it could be more structured by including key details, but it avoids unnecessary verbosity, earning a high score for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 simple input schema, the description is incomplete. It doesn't explain what 'questions' means, the format of the output, or any behavioral traits. For a tool in a complex environment with many siblings, more context is needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'keyword' described as 'Seed keyword'. The description doesn't add any meaning beyond this, such as examples or constraints. Since the schema fully documents the parameter, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les questions liées aux mots-clés' (Get questions related to keywords) states the action and resource but is vague about scope and format. It doesn't differentiate from sibling tools like 'get_keywords_related' or 'get_keywords_similar', which might have overlapping functions. The purpose is clear at a basic level but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With many sibling tools like 'get_keywords_related' and 'get_keywords_similar', the description doesn't explain context, prerequisites, or exclusions. This leaves the agent guessing about appropriate usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_scrapD
Extraire les mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keywords | Yes | Specific data fields to request |
TDQS
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. 'Extraire les mots-clés' implies a read operation but gives no information about permissions, rate limits, data sources, output format, or error handling. For a tool with no annotation coverage, this description fails to provide essential behavioral context needed for reliable invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While concise with a single phrase, this is under-specification rather than effective brevity. The description fails to provide necessary context and differentiation that would help an agent use the tool correctly. Every word should earn its place, but here the minimal content doesn't fulfill the description's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by sibling tools and the lack of annotations and output schema, the description is completely inadequate. It doesn't explain what 'scrap' means, what data source is used, what the extraction process involves, or what format the results take. For a tool with one required parameter and no output schema, this leaves critical gaps in understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'keywords' parameter documented as 'Specific data fields to request'. The description adds no additional meaning beyond this schema information. Since schema coverage is high, the baseline score of 3 is appropriate—the description doesn't compensate but doesn't need to given the schema's completeness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Extraire les mots-clés' (Extract keywords) is a tautology that essentially restates the tool name 'get_keywords_scrap' without adding meaningful specificity. It doesn't clarify what resource is being extracted from, what 'scrap' refers to, or how this differs from sibling tools like 'get_keywords_bulk' or 'get_keywords_find'. The purpose remains vague and indistinguishable from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 multiple sibling tools like 'get_keywords_bulk', 'get_keywords_find', 'get_keywords_overview', and others, there's no indication of context, prerequisites, or distinctions. This leaves the agent with no basis for selecting this specific tool over others in the same domain.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_serp_availableDatesC
Obtenir les dates disponibles des mots-clés dans les SERP.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. The description only states what the tool does ('Obtenir les dates disponibles') but doesn't reveal any behavioral traits - no information about whether this is a read-only operation, potential rate limits, authentication requirements, what format the dates are returned in, or any error conditions. For a tool with no annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
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 without any unnecessary words. It's appropriately sized and front-loaded with the essential information. Every word earns its place in this concise French description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 description that only states the basic purpose, this is incomplete for effective tool use. The agent needs to know what 'dates disponibles' means in practice - date range format, whether this returns historical data, future projections, or something else. For a tool querying SERP data with no structured output documentation, the description should provide more context about what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with the single parameter 'keyword' well-described as 'Seed keyword' in the schema. The description doesn't add any additional parameter semantics beyond what the schema provides. With complete schema coverage, the baseline score of 3 is appropriate - the description doesn't compensate but doesn't need to since the schema handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Obtenir' - Get/Obtain) and the resource ('dates disponibles des mots-clés dans les SERP' - available dates of keywords in SERP). It specifies what the tool does in a straightforward manner. However, it doesn't explicitly differentiate from sibling tools like 'get_keywords_serp_compare' or 'get_keywords_serp_pageEvolution', 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.
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. There are multiple keyword-related tools in the sibling list (e.g., 'get_keywords_serp_compare', 'get_keywords_serp_pageEvolution'), but the description doesn't indicate when this specific 'available dates' functionality is appropriate versus those other SERP-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_serp_compareD
Comparer les mots-clés dans les SERP.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword | |
| period | Yes | Seed keyword |
TDQS
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. However, it only states the action ('compare') without any details on what the tool does (e.g., returns comparison data, requires API keys, has rate limits, or is read-only). This is insufficient for a tool with parameters and no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, vague sentence in French that does not front-load critical information. It is under-specified rather than concise, failing to convey purpose or usage effectively. Every sentence should earn its place, but this one adds minimal value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of keyword comparison, lack of annotations, no output schema, and vague description, this is incomplete. The description does not explain what the tool returns, how it behaves, or when to use it, making it inadequate for an agent to invoke correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters ('keyword' and 'period') documented in the schema as 'Seed keyword'. The description does not add any meaning beyond this, such as explaining what 'period' refers to (e.g., date range, time frame) or how the comparison uses these inputs. Baseline 3 is appropriate since the schema handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Comparer les mots-clés dans les SERP' (Compare keywords in SERPs) is vague and tautological, essentially restating the tool name 'get_keywords_serp_compare' in French. It lacks specificity about what 'compare' entails (e.g., ranking, frequency, trends) and does not distinguish this tool from siblings like 'get_keywords_overview' or 'get_keywords_related', which might also involve keyword analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 any context, prerequisites, or exclusions, nor does it refer to sibling tools. This leaves the agent with no information to decide between this and other keyword-related tools in the list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_serp_pageEvolutionC
Obtenir l'évolution des pages SERP des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword | |
| first_date | Yes | Seed keyword | |
| second_date | Yes | Seed keyword | |
| url | Yes | Seed keyword |
TDQS
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. The description mentions 'évolution' (evolution) which implies tracking changes over time, but it doesn't specify what data is returned, whether it's a read-only operation, if there are rate limits, or any authentication requirements. This leaves significant gaps in understanding 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that efficiently states the tool's purpose. It's appropriately sized for what it communicates, though it could be more informative. There's no unnecessary verbosity or structural issues.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (tracking SERP evolution over time with 4 parameters), lack of annotations, and no output schema, the description is insufficient. It doesn't explain what 'évolution' means in practice, what format the results take, or how the parameters interact. For a tool with this level of complexity and no structured metadata, the description should provide more complete context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all four parameters documented in the schema as 'Seed keyword'. The description doesn't add any meaningful parameter semantics beyond what the schema already provides. It doesn't explain what 'first_date' and 'second_date' represent in the context of evolution tracking, or how 'url' relates to keyword SERP analysis. The baseline score of 3 reflects adequate but minimal value added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose as 'Obtenir l'évolution des pages SERP des mots-clés' (Get the evolution of SERP pages for keywords), which is a clear verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'get_keywords_serp_compare' or 'get_keywords_serp_availableDates', leaving ambiguity about when to use this specific tool versus those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 sibling tools like 'get_keywords_serp_compare' and 'get_keywords_serp_availableDates' that seem related to SERP/keyword analysis, there's no indication of how this tool differs or when it should be preferred over those options.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_similarC
Obtenir des mots-clés similaires.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword |
TDQS
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. The description only states the action ('obtenir') without any details on permissions, rate limits, output format, or side effects. For a tool with unknown behavior and no annotations, this is a significant gap that leaves the agent uninformed about how the tool operates.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly, though its brevity contributes to gaps in other dimensions like guidelines and transparency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a keyword similarity tool with no annotations and no output schema), the description is incomplete. It lacks details on behavioral traits, usage context, and output expectations, making it inadequate for the agent to understand how to effectively invoke and interpret results from this tool in a server with many sibling keyword tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'keyword' documented as 'Seed keyword'. The description doesn't add any meaning beyond this, such as examples or constraints. With high schema coverage, the baseline score is 3, as the schema adequately handles parameter documentation without extra help from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir des mots-clés similaires' (Get similar keywords) restates the tool name 'get_keywords_similar' in French, making it tautological. It specifies the verb 'obtenir' (get) and resource 'mots-clés similaires' (similar keywords), but doesn't differentiate from siblings like 'get_keywords_related' or 'get_keywords_synonyms' that might serve similar purposes, leaving the agent uncertain about which tool to use for keyword similarity tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'get_keywords_related' and 'get_keywords_synonyms' that likely handle keyword relationships, the agent receives no explicit or implied context for choosing this tool, leading to potential misuse or confusion in tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_site_structureC
Obtenir la structure du site des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | No | Seed keyword | |
| keywords | No | Seed keyword |
TDQS
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 the action ('Obtenir') but doesn't reveal any behavioral traits such as whether it's a read-only operation, requires authentication, has rate limits, returns structured data, or involves pagination. For a tool with no annotations, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly. Every part of the sentence contributes to understanding the tool's intent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain what 'site structure' entails, how results are returned, or any behavioral aspects. For a tool with no output schema and no annotations, the description should provide more context about the operation and expected outcomes to be adequately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for its 2 parameters ('keyword' and 'keywords'), both described as 'Seed keyword'. The description adds no meaning beyond this, not explaining the relationship between the two parameters (e.g., if one is singular and the other an array for bulk processing). With high schema coverage, the 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir la structure du site des mots-clés' (Get the site structure of keywords) states a purpose but is vague. It specifies a verb ('Obtenir') and resource ('structure du site des mots-clés'), but doesn't clarify what 'site structure' means in this context or how it differs from sibling tools like get_keywords_related or get_keywords_similar. The purpose is understandable but lacks specificity for differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 many sibling tools focused on keywords (e.g., get_keywords_related, get_keywords_overview), there's no indication of context, prerequisites, or exclusions. Usage is implied only by the tool name and description, leaving the agent to guess based on naming patterns.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_keywords_synonymsC
Obtenir les synonymes des mots-clés.
| Name | Required | Description | Default |
|---|---|---|---|
| keyword | Yes | Seed keyword |
TDQS
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. The description only states what the tool does ('get synonyms') without revealing any behavioral traits: no information about rate limits, authentication requirements, response format, pagination, or whether this is a read-only operation. For a 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise - a single French sentence that directly states the tool's purpose without any wasted words. It's appropriately sized for a simple lookup tool and gets straight to the point with no unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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. For a tool that presumably returns synonym data, there's no information about the response format, structure, or what the agent can expect. The description does the minimum job of stating the purpose but fails to provide the context needed for effective tool use in a complex sibling environment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'keyword' documented as 'Seed keyword.' The description doesn't add any parameter semantics beyond what the schema provides - it doesn't clarify what constitutes a valid keyword, format requirements, or examples. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les synonymes des mots-clés' clearly states the tool's purpose: to retrieve synonyms for keywords. It uses a specific verb ('Obtenir' - get/retrieve) and identifies the resource ('synonymes des mots-clés'). However, it doesn't explicitly differentiate from sibling tools like 'get_keywords_related' or 'get_keywords_similar', which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 multiple sibling tools focused on keywords (e.g., get_keywords_related, get_keywords_similar, get_keywords_find), there's no indication of what distinguishes this synonym-focused tool from those potentially related tools. The agent receives no usage context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_page_best_keywordsC
Obtenir les meilleurs mots-clés de la page.
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | Specific data fields to request |
TDQS
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 only states what the tool does without mentioning any behavioral traits such as whether it's a read-only operation, requires authentication, has rate limits, or what the output format might be. For a tool with no annotations, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French, making it concise and front-loaded. However, it's under-specified for the tool's complexity, as it lacks details that would help an agent use it effectively, slightly reducing its utility despite the brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (inferred from sibling tools and lack of output schema), the description is incomplete. With no annotations, no output schema, and a vague purpose, it fails to provide enough context for an agent to understand how to invoke it correctly or what to expect in return, making it inadequate for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'input' documented as 'Specific data fields to request'. The description adds no additional meaning beyond this, as it doesn't explain what 'input' should contain (e.g., what data fields are valid) or how it relates to getting keywords. With high schema coverage, the 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose as 'Obtenir les meilleurs mots-clés de la page' (Get the best keywords of the page), which is clear but vague. It specifies the verb 'obtenir' (get) and resource 'mots-clés de la page' (keywords of the page), but doesn't clarify what 'best' means or how it differs from sibling tools like get_keywords_bulk or get_keywords_related, making it moderately helpful but lacking specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 many sibling tools related to keywords (e.g., get_keywords_bulk, get_keywords_related, get_keywords_overview), there's no indication of context, prerequisites, or exclusions, leaving the agent to guess based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_user_creditB
Obtenir les informations de crédit de l'utilisateur.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. The description only states what the tool does ('obtain user credit information') without revealing any behavioral traits such as whether it requires authentication, what format the credit information returns, whether it has rate limits, or if it's a read-only operation. For a tool with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in French that directly states the tool's purpose without any wasted words. It's appropriately sized for a simple tool with no parameters and gets straight to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a tool with no annotations, no output schema, and no parameters, the description is incomplete. It states what the tool does but provides no information about what 'credit information' includes, the format of the response, authentication requirements, or any behavioral context. For a tool that presumably returns user account data, this leaves significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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. The description doesn't need to explain parameters since none exist. The baseline for 0 parameters is 4, as the description appropriately focuses on the tool's purpose rather than parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Obtenir les informations de crédit de l'utilisateur' clearly states the tool's purpose as retrieving user credit information. It specifies the verb 'obtenir' (get) and the resource 'informations de crédit de l'utilisateur' (user credit information). However, it doesn't explicitly differentiate from sibling tools, which all appear to be domain/keyword-related except for set_api_key, so the distinction is implicit rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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, context, or exclusions. While the tool name and description suggest it's for user credit info (unlike sibling tools focused on domains/keywords), this distinction isn't explicitly stated in the description itself.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
set_api_keyC
Définir la clé API.
| Name | Required | Description | Default |
|---|---|---|---|
| apiKey | Yes | Your Haloscan API key |
TDQS
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. 'Définir' implies a mutation/write operation, but the description doesn't specify whether this persists across sessions, what permissions are required, whether it overwrites existing keys, or what happens on success/failure. For a configuration tool with zero annotation coverage, this leaves critical behavioral questions unanswered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just three words, with no wasted language. However, this brevity comes at the cost of under-specification - it's so minimal that it fails to provide adequate context. Still, as a standalone statement, it's efficiently structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a configuration tool with no annotations and no output schema, the description is inadequate. It doesn't explain what system this configures, whether the change is persistent, what happens on success, or any error conditions. Given this tool's apparent role as the only configuration mechanism among many data retrieval siblings, the description should provide more complete context about its purpose and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'apiKey' clearly documented as 'Your Haloscan API key'. The description adds no additional parameter information beyond what the schema provides. With complete schema coverage, the baseline score of 3 is appropriate since the schema already does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Définir la clé API' is a tautology that essentially restates the tool name 'set_api_key' in French. It doesn't specify what resource or system this API key is for, nor does it distinguish this tool from any potential alternatives. While it indicates an action ('définir' meaning 'set'), it lacks specificity about what exactly is being configured.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides absolutely no guidance on when to use this tool versus alternatives. Given the sibling tools are all 'get_' operations for data retrieval, this appears to be the only configuration tool, but the description doesn't mention this distinction, prerequisites for use, or any contextual triggers for when this operation is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Most tools have distinct purposes focused on specific data types like domains, keywords, or pages, with clear naming that reduces overlap. However, some tools like get_keywords_find and get_keywords_scrap might be slightly ambiguous in their exact scope, though descriptions help differentiate them.
All tools follow a consistent snake_case pattern with a clear get_ or set_ prefix followed by resource and action, such as get_domains_overview or set_api_key. This uniformity makes the tool set predictable and easy to navigate.
With 33 tools, the count is excessive for a typical MCP server, likely overwhelming for agents and indicating poor scoping. While the domain (SEO/domain analysis) is broad, many tools could be consolidated or omitted without losing functionality.
The tool set comprehensively covers the SEO and domain analysis domain, including operations for domains, keywords, pages, and user management. It provides full lifecycle coverage with get operations for various data points and a set_api_key for configuration, leaving no obvious gaps.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
SEO MCP server for keyword research, SERP analysis, audits, and Search Console workflows.
SEO Intelligence MCP — 13 tools: keyword research, SERP, domain audits, competitors.
MCP server: 447 pay-as-you-go research tools (SEO, ads, SERP) + verified prowl_analyze reports
SEO MCP server — backlinks, domain authority, tech stack, and 18+ tools via Common Crawl.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceMCP server that enables AI assistants to perform SEO automation tasks including keyword research, SERP analysis, and competitor analysis through Google Ads API integration.1
- -licenseCqualityNot gradedmaintenanceA Model Context Protocol server that exposes Haloscan SEO API functionality, allowing users to access keyword insights, domain analysis, and competitor research through Claude for Desktop and other MCP-compatible clients.3266
- AlicenseAqualityDmaintenanceAn MCP server that provides access to the Majestic SEO API, allowing users to retrieve metrics like Trust Flow, Citation Flow, and backlink data. It enables domain comparisons, anchor text analysis, and tracking of new or lost backlinks through nine specialized tools.914MIT
- FlicenseNot gradedqualityDmaintenanceMCP server for Keys.so SEO API, enabling domain and keyword analysis, competitor research, and SEO metrics retrieval through natural language.4
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/Cryptoptimiste/HaloscanMCPServer'
If you have feedback or need assistance with the MCP directory API, please join our Discord server