IPInfo MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation3/5
Most tools have distinct purposes, but there is significant overlap between the single-field IP lookup tools (e.g., get_ip_city, get_ip_country, get_ip_hostname) and the comprehensive get_ip_info, which could cause confusion about which to use. The WHOIS tools are well-differentiated by target (ASN, domain, IP).
Naming Consistency4/5
The naming follows a consistent verb_noun pattern (e.g., get_ip_info, get_asn_info, whois_lookup_by_domain) with minor deviations like batch_lookup (missing 'get_' prefix) and map_ips/summarize_ips (using verbs instead of 'get_'). Overall, it's readable and predictable.
Tool Count2/5
With 23 tools, the count feels excessive for an IP information server. Many tools are redundant (e.g., multiple single-field IP lookups) or could be consolidated (e.g., WHOIS lookups into one tool with parameters). This may overwhelm agents and increase misselection risk.
Completeness5/5
The toolset comprehensively covers the IP information domain, including IP lookups (batch, single, detailed, specific fields), ASN/company/carrier info, abuse contacts, privacy detection, WHOIS lookups, mapping, summarization, and account management. No obvious gaps exist for core workflows.
Average 3.5/5 across 23 of 23 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- Last stable release on May 27, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool 'Get information' but doesn't specify whether this is a read-only operation, if it requires authentication, rate limits, or error handling. While it implies a safe read operation, it lacks details on permissions, data freshness, or response structure beyond a vague mention of return types.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and well-structured. It starts with a clear purpose statement, followed by separate 'Args' and 'Returns' sections that organize information efficiently. There is no redundant or verbose language, making it easy to parse. A slight deduction because the 'Returns' section could be more specific, but overall it's front-loaded and concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter, no annotations, but with an output schema), the description is partially complete. It covers the basic purpose and parameter format but lacks usage guidelines and detailed behavioral context. The presence of an output schema means the description doesn't need to explain return values in depth, but it should still address when to use this tool over siblings and operational constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal semantics beyond the input schema. It specifies that the 'asn' parameter is 'The ASN number (without 'AS' prefix)', which clarifies formatting not evident from the schema's integer type alone. However, with 0% schema description coverage and only one parameter, this addition is basic. It doesn't explain validation rules, example values, or edge cases, keeping it at the baseline for low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get information about an Autonomous System Number (ASN).' It specifies the verb ('Get') and resource ('ASN information'), making it understandable. However, it doesn't explicitly differentiate this from sibling tools like 'whois_lookup_by_asn' or 'get_ip_org', which might offer overlapping or related functionality, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools such as 'whois_lookup_by_asn', 'get_ip_org', and 'get_ip_ranges' that might retrieve similar or related network data, there is no indication of context, prerequisites, or exclusions. This lack of differentiation leaves the agent without clear usage cues.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic action and return values, without mentioning any behavioral traits like rate limits, authentication needs, error handling, or data freshness. This is a significant gap for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by structured 'Args' and 'Returns' sections. It's efficient with no wasted sentences, though the formatting could be more integrated (e.g., as a single paragraph). Overall, it's appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter) and the presence of an output schema (implied by 'Returns' details), the description is minimally complete. However, it lacks context on sibling differentiation and behavioral traits, which are needed for optimal agent use. The output schema reduces the burden, but gaps remain in usage and transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal semantics: it names the parameter ('ip') and specifies it as 'IP address to lookup', which provides basic meaning beyond the schema's type ('string'). However, with 0% schema description coverage, it doesn't fully compensate—e.g., no format details (IPv4 vs. IPv6) or validation rules. The baseline is 3 due to the single parameter being straightforward.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get company information for an IP address.' It specifies the verb ('Get') and resource ('company information'), but does not explicitly differentiate it from sibling tools like 'get_ip_org' or 'get_ip_info', which might provide overlapping or related data. This makes it clear but not fully distinct from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus its many siblings, such as 'get_ip_org' or 'get_ip_info'. It lacks context on use cases, exclusions, or alternatives, leaving the agent to infer usage based on the tool name alone, which is insufficient given the crowded namespace of IP-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions pagination ('page' and 'limit' parameters) and a default limit, which adds some context. However, it lacks details on rate limits, authentication needs, error handling, or data freshness, which are important for a lookup tool. The description doesn't contradict any annotations, but it's insufficient for full transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized, with a clear purpose statement followed by sections for 'Args' and 'Returns'. Each sentence adds value, and there's no redundant information. It could be slightly more concise by integrating the parameter details into the main text, but overall it's efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there's an output schema (which covers return values), no annotations, and moderate complexity with 3 parameters, the description is somewhat complete. It explains the purpose and parameters but lacks behavioral context like rate limits or error handling. For a lookup tool with pagination, more guidance on usage and limitations would improve completeness, but the output schema reduces the burden.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the 'ip' parameter as 'IP address to lookup', 'page' as 'Page number (starts at 0)', and 'limit' as 'Number of results per page (max 1000, default 100)'. This adds meaningful semantics beyond the schema, covering all three parameters. However, it doesn't provide examples or format details (e.g., IPv4 vs. IPv6 for 'ip'), so it's adequate but not comprehensive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get domains hosted on an IP address.' This is a specific verb ('Get') and resource ('domains hosted on an IP address'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_ip_hostname' or 'whois_lookup_by_ip', which might have overlapping functionality, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any context, prerequisites, or exclusions, nor does it refer to sibling tools like 'get_ip_hostname' or 'whois_lookup_by_ip' that might serve similar purposes. This leaves the agent without clear usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool returns a 'summary report with statistics and map URL,' which gives some output context, but lacks details on performance (e.g., processing time for large lists), error handling, or any side effects. For a tool handling up to 500,000 IPs, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the core purpose stated first. The Args and Returns sections are structured clearly, though they could be integrated more seamlessly. There's minimal waste, but it could be slightly more concise by merging the sections into a single paragraph without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which likely covers return values), the description doesn't need to detail the report structure. However, with no annotations and a single parameter at 0% schema coverage, the description provides basic purpose and parameter info but lacks usage context and behavioral details. It's adequate as a minimum viable description but has clear gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It adds value by specifying the 'ips' parameter as a 'List of IP addresses to summarize (up to 500,000),' which clarifies the format and constraint beyond the schema's basic array type. However, it doesn't explain IP format requirements (e.g., IPv4 vs. IPv6) or validation rules, leaving some semantics unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Summarize a list of IP addresses with statistics and insights.' This specifies the verb ('summarize'), resource ('IP addresses'), and output type ('statistics and insights'). However, it doesn't explicitly differentiate from sibling tools like 'map_ips' or 'get_ip_info', which might provide overlapping functionality, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions a limit of 'up to 500,000' IPs in the Args section, but this is parameter-specific and doesn't address broader context. There's no indication of when this summary tool is preferred over other IP-related tools in the sibling list, such as 'get_ip_info' for individual IPs or 'map_ips' for mapping.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions pagination ('page number for paginated results') and source filtering, but lacks critical details like rate limits, authentication requirements, error handling, or whether this is a read-only operation. The description is insufficient for a tool with 3 parameters and 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet-like formatting. It's appropriately sized at 5 sentences, with the purpose stated upfront. Minor improvements could include more front-loading of key information, but overall it's efficient with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters with 0% schema coverage and no annotations, but with an output schema present, the description is moderately complete. It covers the basic purpose and parameters, but lacks behavioral context (rate limits, auth, errors) and usage guidance. The output schema reduces the need to describe return values, but more operational details would be beneficial for this lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It lists all 3 parameters with brief explanations: 'domain: Domain name to lookup', 'page: Page number for paginated results', and 'source: Filter by WHOIS source (arin, ripe, afrinic, apnic, lacnic)'. This adds meaningful context beyond the bare schema, but doesn't provide format examples, constraints, or default behaviors for optional parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs a 'WHOIS lookup by organization domain' and returns 'WHOIS records for the domain', specifying both the action (lookup) and resource (WHOIS records). It distinguishes from siblings like 'whois_lookup_by_asn' and 'whois_lookup_by_ip' by specifying the domain-based lookup, though it doesn't explicitly contrast with all siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'whois_lookup_by_ip' or 'get_ip_info', nor does it specify use cases, prerequisites, or exclusions for domain-based WHOIS lookups.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions creating a 'visual map' and returning a 'Map report with visualization URL,' which implies a read-only operation with visual output. However, it lacks details on permissions, rate limits (e.g., handling up to 500,000 IPs), error handling, or whether the map is interactive or static. For a tool with no annotations, this is insufficient to fully inform the agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with a clear purpose statement followed by 'Args' and 'Returns' sections. Each sentence adds value: the first defines the tool, the second details the parameter, and the third specifies the output. There is no wasted text, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which should cover return values), the description does not need to explain returns in detail. However, with no annotations and 0% schema description coverage, it partially compensates by clarifying the parameter. For a tool that creates visualizations, it lacks context on map types, formats, or integration hints, leaving some gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It adds meaningful context: the 'ips' parameter is described as a 'List of IP addresses to map (up to 500,000),' clarifying the data type, purpose, and a practical limit. This goes beyond the basic schema, providing essential usage semantics that the schema alone does not cover.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Create a visual map of IP address locations.' It specifies the verb ('Create'), resource ('visual map'), and scope ('IP address locations'), which is specific and actionable. However, it does not explicitly differentiate from sibling tools like 'get_ip_location' or 'summarize_ips', which might offer similar or overlapping functionality, so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_ip_location' (which might return location data without visualization) and 'summarize_ips' (which could aggregate IP data), there is no explicit or implied context for choosing this tool over others. This lack of differentiation leaves usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions pagination and source filtering, which are useful, but doesn't disclose critical traits like rate limits, authentication needs, error conditions, or whether this is a read-only operation. For a lookup tool 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet-like formatting. It's front-loaded with the core purpose. However, the 'Returns' section is somewhat redundant given the output schema, and some sentences could be more tightly integrated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters with 0% schema coverage and an output schema, the description partially compensates by explaining parameters but lacks behavioral context. It doesn't cover error handling, rate limits, or sibling differentiation. The output schema reduces need for return value details, but overall completeness is moderate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It successfully explains all 3 parameters: asn (ASN number), page (for paginated results), and source (with specific WHOIS sources listed). This adds meaningful context beyond the bare schema, though it could detail format constraints like ASN ranges.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs a WHOIS lookup by ASN, which is a specific verb (lookup) and resource (WHOIS records for ASN). It distinguishes from siblings like whois_lookup_by_domain and whois_lookup_by_ip by specifying the ASN parameter type. However, it doesn't explicitly contrast with get_asn_info, which might provide overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like get_asn_info or other WHOIS lookup siblings. The description mentions parameters but doesn't explain use cases, prerequisites, or exclusions. This leaves the agent without contextual decision-making help.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It mentions that IPs 'can include field paths like "8.8.8.8/city"' which hints at extended functionality, but doesn't describe rate limits, authentication needs, error handling, or what specific information is returned. For a batch operation with zero 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement followed by Args and Returns sections. Every sentence earns its place: the first establishes core functionality, the second explains parameter semantics with a helpful example, and the third describes the return format. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (batch operation with field path syntax), no annotations, but with an output schema present, the description is minimally adequate. The output schema reduces the need to detail return values, but the description lacks context about performance, limitations, or how it relates to the many sibling tools. It's complete enough for basic use but leaves gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for the single parameter, the description compensates well by explaining the 'ips' parameter accepts 'List of IP addresses to lookup' and provides an example of field path syntax. This adds meaningful context beyond the bare schema, though it doesn't detail format constraints or validation rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Batch lookup multiple IP addresses' with a specific verb ('lookup') and resource ('IP addresses'). It distinguishes itself from siblings by emphasizing batch capability, though it doesn't explicitly name alternatives. The description avoids tautology by providing meaningful context beyond just the name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the many sibling IP lookup tools (e.g., get_ip_info, get_ip_city, map_ips). It mentions batch capability but doesn't specify thresholds, performance considerations, or alternative tools for single IP lookups. There's no explicit when/when-not guidance or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool returns 'API limits and available features,' which hints at read-only behavior, but doesn't explicitly state whether this is a safe read operation, requires authentication, has rate limits, or other behavioral traits. The disclosure is incomplete for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured: the first sentence states the purpose, and the second clarifies the return values. Every sentence adds value without any wasted words, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, output schema exists), the description is adequate but has gaps. It covers the purpose and return values, but lacks usage guidelines and full behavioral transparency. With an output schema, it doesn't need to detail return values, but other aspects are minimally addressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter explanation in the description. The baseline for this scenario is 4, as the description appropriately avoids redundant parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('IPInfo account information and API limits'), making it immediately understandable. However, it doesn't explicitly differentiate this tool from its siblings (which are all IP/domain lookup tools), so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, appropriate contexts, or relationships to sibling tools like batch_lookup or get_ip_info, leaving the agent without usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns 'IP ranges information including IPv4 and IPv6 blocks,' which hints at output format, but lacks details on rate limits, authentication needs, error handling, or whether it's a read-only operation. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured: a clear purpose statement followed by 'Args' and 'Returns' sections. Every sentence earns its place by defining the tool, parameter, and output without redundancy. It's front-loaded with the core functionality and appropriately sized for a simple lookup tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter) and the presence of an output schema (which likely covers return values), the description is minimally adequate. It explains the parameter and output at a high level but lacks behavioral details like error cases or usage context. With no annotations and simple schema, it meets basic needs but could be more informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter: 'domain: Domain name to lookup.' Since schema description coverage is 0% (the schema only provides a title 'Domain' with no description), this compensates well by explaining the parameter's purpose. However, it doesn't specify format constraints (e.g., TLD requirements) or examples, preventing a perfect score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get IP ranges owned by a domain/organization.' It specifies the verb ('Get') and resource ('IP ranges'), and distinguishes it from siblings like get_ip_info or get_ip_org by focusing on ownership mapping rather than general IP information. However, it doesn't explicitly contrast with similar tools like get_hosted_domains or whois_lookup_by_domain, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like get_ip_org (which might return organization info for an IP) or whois_lookup_by_domain (which could provide related domain data), nor does it specify prerequisites or exclusions. The agent must infer usage from the purpose alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'Get[s] abuse contact information' but doesn't mention if this is a read-only operation, requires authentication, has rate limits, or what happens on errors (e.g., invalid IP). For a tool with no annotations, this leaves significant gaps in understanding its behavior and constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by brief sections for args and returns. Every sentence earns its place: the first states the goal, and the subsequent lines efficiently clarify inputs and outputs without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter), no annotations, and the presence of an output schema (implied by 'Returns' section), the description is reasonably complete. It covers purpose, input, and output, though it could improve by addressing behavioral aspects like error handling or usage context relative to siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description compensates by explaining the 'ip' parameter as 'IP address to lookup'. This adds clear meaning beyond the bare schema. However, it doesn't specify format details (e.g., IPv4 vs. IPv6) or validation rules, which could be useful given the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get abuse contact information for an IP address.' It specifies the verb ('Get'), resource ('abuse contact information'), and target ('IP address'). However, it doesn't explicitly differentiate from sibling tools like 'get_ip_info' or 'whois_lookup_by_ip', which might provide overlapping or related data, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings such as 'get_ip_info', 'whois_lookup_by_ip', and 'get_privacy_info', it's unclear if this is the preferred method for abuse contacts or if other tools might offer similar or complementary data. No exclusions or specific contexts are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions pagination ('page number for paginated results') and source filtering, which adds some context. However, it lacks details on rate limits, authentication needs, error handling, or whether this is a read-only operation (implied by 'lookup' but not confirmed). For a tool with no annotations, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by clear sections for Args and Returns. Every sentence earns its place by providing essential information without redundancy. It's appropriately sized for a tool with three parameters and an output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is fairly complete. It covers the purpose, parameters, and return value. The output schema exists, so the description doesn't need to explain return values in detail. However, it lacks context on error cases or performance considerations, which could be useful for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It effectively explains all three parameters: 'ip' as the target for lookup, 'page' for pagination, and 'source' with specific filter options (arin, ripe, etc.). This adds meaningful semantics beyond the bare schema, though it doesn't detail format constraints (e.g., IP address validation) or default behaviors beyond null defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs a 'WHOIS lookup by IP address or IP range,' which is a specific verb+resource combination. It distinguishes itself from sibling tools like 'whois_lookup_by_domain' and 'whois_lookup_by_asn' by specifying the IP-based lookup, though it doesn't explicitly contrast with other IP-related tools like 'get_ip_info' or 'get_ip_ranges' in the description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or contexts where other tools might be more appropriate, such as using 'get_ip_info' for general IP details or 'whois_lookup_by_domain' for domain-based lookups. Usage is implied by the name and description but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does (lookup) and returns (carrier details with MCC/MNC codes), but it doesn't disclose critical traits like whether it's a read-only operation, rate limits, authentication needs, error handling, or data freshness. For a lookup tool with zero annotation coverage, this is a significant gap, though it's not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by structured 'Args' and 'Returns' sections. Every sentence earns its place by providing essential information without redundancy. It's efficient and well-organized for a tool with one parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter) and the presence of an output schema (implied by 'Returns' section), the description is mostly complete. It covers purpose, parameter semantics, and return values. However, with no annotations, it lacks behavioral context like safety or performance traits. For a simple lookup tool, this is adequate but could be improved with more disclosure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It adds meaning by specifying that the 'ip' parameter is an 'IP address to lookup', which clarifies its purpose beyond the schema's generic 'string' type. However, it doesn't provide format details (e.g., IPv4 vs. IPv6) or validation rules. With one parameter and no schema descriptions, this is good but not exhaustive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get mobile carrier information for an IP address.' It specifies the verb ('Get') and resource ('mobile carrier information'), and distinguishes it from siblings by focusing on carrier details rather than general IP info, location, or other lookups. However, it doesn't explicitly differentiate from all siblings (e.g., 'get_ip_info' might overlap in scope), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'for an IP address' and mentioning mobile carrier details, suggesting it's for IP-to-carrier mapping. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_ip_info' or 'get_ip_location', nor does it provide exclusions or prerequisites. The context is clear but lacks explicit guidance on sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It mentions that omitting the IP returns the current location, which is useful context, but does not cover other aspects like rate limits, authentication needs, error handling, or data sources. For a tool with no annotations, this leaves significant gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by structured 'Args' and 'Returns' sections. Every sentence earns its place without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter) and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose, parameter semantics, and return format. However, without annotations, it lacks details on behavioral aspects like rate limits or errors, which could be important for robust usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the 'ip' parameter: 'IP address to lookup. If None, returns current location.' This adds meaning beyond the schema by clarifying the default behavior. However, it does not detail format constraints (e.g., IPv4 vs. IPv6) or validation rules, slightly limiting completeness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get just the coordinates for an IP address.' It specifies the verb ('Get') and resource ('coordinates'), but does not explicitly differentiate from siblings like 'get_ip_city' or 'get_ip_country' beyond the focus on coordinates. The title is null, so the description carries the full burden.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by stating 'If None, returns current location,' which suggests when to omit the parameter, but does not provide explicit guidance on when to use this tool versus alternatives like 'get_ip_info' or 'map_ips.' No exclusions or comparisons to siblings are mentioned, leaving usage context partially implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the default behavior (returning current region if ip is None) but lacks details on permissions, rate limits, error handling, or what 'current region' means (e.g., based on server location or user context). This is a significant gap for a tool with potential external dependencies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by structured Args and Returns sections. It is efficient with minimal waste, though the formatting could be slightly more polished (e.g., using bullet points).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (IP lookup with a default behavior), no annotations, and an output schema (implied by Returns section), the description is adequate but incomplete. It covers the basic operation and parameters but lacks behavioral details like error cases or performance considerations, which are important for external API tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context beyond the input schema, which has 0% description coverage. It explains that the 'ip' parameter is optional (None returns current region) and clarifies the return value as a region or state name, compensating well for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('region/state for an IP address'), distinguishing it from siblings like get_ip_city, get_ip_country, and get_ip_location. It explicitly focuses on region/state extraction rather than broader location data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by mentioning that if 'ip' is None, it returns the current region, suggesting a default behavior. However, it does not explicitly state when to use this tool versus alternatives like get_ip_info or get_ip_location, nor does it provide exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the return type ('IANA timezone string') and the default behavior when 'ip' is None, which adds useful context. However, it lacks details on error handling, rate limits, authentication needs, or performance characteristics, leaving gaps for a tool that interacts with external data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by structured 'Args' and 'Returns' sections. Each sentence earns its place by providing essential information without redundancy. It could be slightly more concise by integrating the default behavior into the main sentence, but overall it's efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameter semantics, and return type. However, it lacks context on potential errors or limitations, which would be helpful for robust agent usage, though the output schema may mitigate this.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It adds meaning by explaining that 'ip' is an 'IP address to lookup' and specifies the default behavior ('If None, returns current timezone'), which clarifies the parameter's purpose beyond the schema's basic type and default. This adequately covers the single parameter, though it doesn't detail format constraints (e.g., IPv4 vs. IPv6).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get just the timezone for an IP address.' It specifies the verb ('Get') and resource ('timezone for an IP address'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_ip_city' or 'get_ip_country', which likely provide related but different geographical data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by stating that if 'ip' is None, it returns the current timezone, suggesting this tool can handle both IP lookups and default cases. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_ip_info' or 'get_ip_location', which might offer broader or overlapping data. No exclusions or clear alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states what the tool does but lacks behavioral details such as rate limits, authentication requirements, error handling, or whether it performs external API calls. It doesn't disclose any operational constraints beyond the basic functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by structured sections for Args and Returns. Every sentence adds value without redundancy, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which covers return values) and a simple input schema with one parameter, the description provides sufficient context for basic use. However, as a detection tool with no annotations, it could benefit from more behavioral details like accuracy notes or limitations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'ip' by specifying it's 'IP address to check,' which clarifies its purpose beyond the schema's basic type. With 0% schema description coverage and only one parameter, this compensates adequately, though it doesn't detail format constraints like IPv4 vs. IPv6.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Detect privacy services') and resource ('for an IP address'), distinguishing it from sibling tools like get_ip_info or get_ip_location that focus on different IP attributes. It explicitly lists the types of privacy services detected (VPN, proxy, Tor, relay, hosting).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through 'privacy services detection,' suggesting it's for identifying anonymization services, but it doesn't explicitly state when to use this tool versus alternatives like get_ip_info or other sibling tools. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks behavioral details. It mentions the default behavior (returns current hostname if ip is None) but doesn't cover error handling, rate limits, network dependencies, or authentication needs. This is inadequate for a network tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by well-structured Args and Returns sections. Every sentence earns its place, with no redundant or verbose content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter) and the presence of an output schema (which covers return values), the description is mostly complete. However, it lacks context about network behavior or error cases, which would be helpful despite the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate fully. It clearly explains the single parameter 'ip', including its purpose ('IP address to lookup') and special behavior ('If None, returns current hostname'), adding crucial meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get just the hostname') and resource ('for an IP address'), distinguishing it from siblings like get_ip_info (general info) or get_ip_location (geographic data). It precisely defines the tool's narrow scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for IP-to-hostname resolution, with no explicit alternatives or exclusions mentioned. It doesn't specify when to use this versus siblings like get_ip_info (which might include hostname) or batch_lookup (for multiple IPs), leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the default behavior (returns current IP if ip is None) and hints at the return content (location, ASN, company, privacy). However, it lacks details on rate limits, authentication needs, error handling, or data freshness, which are important for a lookup tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement, Args section, and Returns section. It's front-loaded and efficient, though the 'ctx: MCP context' in Args adds minimal value and could be omitted for better conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (IP lookup), no annotations, and an output schema present, the description is fairly complete. It covers purpose, parameter semantics, and return content. However, it could improve by mentioning potential limitations or linking to sibling tools for specialized data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the 'ip' parameter's purpose and default behavior (if None, returns current IP), adding meaningful semantics beyond the bare schema. With only one parameter, this is sufficient to earn a high score, though it could note format expectations (e.g., IPv4/IPv6).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('comprehensive information about an IP address'), making the purpose specific. It distinguishes from siblings like get_ip_city or get_ip_country by emphasizing 'comprehensive' information, indicating broader scope than those specialized tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage: it's for IP address lookups, with a default behavior when ip is None (returns current IP info). However, it doesn't explicitly state when to use this versus alternatives like get_ip_location or get_asn_info, which are more specialized siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the default behavior (returns current city if IP is None) and the return type (city name), but lacks details on error handling, rate limits, data sources, or privacy implications. It provides basic behavioral context but misses advanced traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by clear Arg and Returns sections. Every sentence earns its place with no redundancy, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter) and the presence of an output schema (which handles return values), the description is mostly complete. It covers purpose, parameter semantics, and return type adequately, though it could benefit from more behavioral context like error cases or data freshness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the 'ip' parameter's purpose and the special case when None (returns current city), adding meaningful semantics beyond the schema's basic type and default. However, it doesn't specify format constraints (e.g., IPv4 vs. IPv6) or validation rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get just the city') and resource ('for an IP address'), distinguishing it from siblings like get_ip_country, get_ip_region, or get_ip_info. It precisely defines the scope of what is returned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly suggests usage for retrieving city-level information from an IP, with the default behavior (no IP provided) returning the current city. However, it lacks explicit guidance on when to use this versus alternatives like get_ip_location or get_ip_info, which might provide more comprehensive data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: the tool returns a two-letter country code (ISO-3166) and handles a null IP by returning the current country. However, it lacks details on error handling, rate limits, or data sources, which are important for a lookup tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by structured 'Args' and 'Returns' sections. Every sentence earns its place, with no redundant or verbose content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (implied by 'Returns' section), the description is mostly complete. It covers purpose, parameter behavior, and return value. However, it could benefit from mentioning error cases or data source limitations for full completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning beyond the schema by explaining the parameter's purpose ('IP address to lookup') and special behavior ('If None, returns current country'). This covers the single parameter's semantics well, though it could specify format constraints (e.g., IPv4/IPv6).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get just the country code for an IP address.' It specifies the verb ('Get'), resource ('country code'), and scope ('for an IP address'), and distinguishes it from siblings like get_ip_city, get_ip_region, and get_ip_info by focusing exclusively on the country code.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage: 'If None, returns current country.' This indicates when to omit the parameter. However, it does not explicitly state when to use this tool versus alternatives like get_ip_info (which might include country and other details) or batch_lookup (for multiple IPs), leaving some sibling differentiation implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the special behavior when ip=None ('returns current organization'), which is valuable context not in the schema. However, it doesn't mention rate limits, error conditions, authentication requirements, or what 'current organization' means in practice, leaving behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured with a clear purpose statement followed by Args and Returns sections. Every sentence earns its place: the first establishes scope, the second explains parameter behavior, and the third defines the return value. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (single parameter with special null behavior), no annotations, but an output schema exists, the description is reasonably complete. It explains the parameter's semantics and return value format. However, it could better address what 'current organization' means and potential error cases, keeping it from a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for the single parameter, the description adds significant value by explaining the ip parameter's purpose and special null behavior. It clarifies that 'If None, returns current organization,' which provides essential semantics beyond the schema's type information. The description fully compensates for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get just the organization/ASN') and resource ('for an IP address'), distinguishing it from siblings like get_ip_info, get_ip_country, or get_ip_location that provide different types of IP information. The verb 'Get' combined with the specific scope 'organization/ASN' makes the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use this tool ('Get just the organization/ASN for an IP address') and implicitly distinguishes it from siblings that return different IP attributes. However, it doesn't explicitly state when NOT to use it or name specific alternatives, which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context: the default behavior when ip is None (returns current postal code) and the return type (Postal or ZIP code). However, it omits details like error handling, rate limits, or data source, which are important for a lookup tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by structured Args and Returns sections. Every sentence earns its place by providing essential information without redundancy, making it highly efficient and well-organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity, one parameter, and an output schema (which handles return values), the description is nearly complete. It covers purpose, parameter semantics, and return type. However, it could improve by mentioning data accuracy or limitations, slightly reducing completeness for a lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description must compensate fully. It does so by explaining the single parameter 'ip' in detail: its purpose ('IP address to lookup'), optionality ('If None'), and effect ('returns current postal code'). This adds significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get just the postal code') and resource ('for an IP address'), distinguishing it from siblings like get_ip_city, get_ip_country, and get_ip_info by focusing exclusively on postal/ZIP code retrieval. The verb 'Get' is precise and the scope is well-defined.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly provides usage guidance by specifying 'just the postal code,' suggesting this tool should be used when only postal information is needed versus broader tools like get_ip_info. However, it lacks explicit when-not-to-use statements or named alternatives, such as comparing to get_ip_location for more comprehensive data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

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

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

Card Badge

Copy to your README.md:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/NimbleBrainInc/mcp-ipinfo'

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