Joern MCP Server

by sfncat

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation3/5
The tools have clear purposes but significant overlap exists. For example, get_method_code_by_full_name, get_method_code_by_class_full_name_and_method_name, and get_method_code_by_id all retrieve method code with different input parameters, which could confuse agents about which to use. However, descriptions help clarify the distinctions, preventing complete ambiguity.
Naming Consistency4/5
Most tools follow a consistent verb_noun pattern (e.g., get_call_code_by_id, get_method_by_call_id), with minor deviations like check_connection and ping (which are simpler verbs). The naming is generally predictable and readable, though not perfectly uniform across all tools.
Tool Count4/5
With 18 tools, the count is slightly high but reasonable for a code analysis server like Joern, which needs to handle various CPG queries. It covers multiple aspects (methods, classes, calls, loading), though it might feel a bit heavy compared to more focused servers.
Completeness5/5
The tool set provides comprehensive coverage for querying a CPG, including loading, checking connections, and retrieving details on calls, methods, and classes with full lifecycle support (e.g., get, list, derive, parent). No obvious gaps are present for its intended domain of static code analysis.
Average 3.4/5 across 18 of 18 tools scored. Lowest: 2.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It states what the tool does but lacks critical details: it doesn't specify what 'code' means (source code, bytecode, etc.), whether this is a read-only operation, error handling, performance characteristics, or authentication requirements. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and structured with parameter annotations, but it's inefficiently front-loaded. The first sentence states the purpose, but the subsequent @param lines are misleading given the actual schema. While concise, the structure doesn't effectively communicate the tool's true requirements due to the parameter mismatch.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (1 parameter with 0% schema coverage, no output schema, no annotations), the description is incomplete. It fails to accurately document the single required parameter ('method_id'), doesn't explain the return value beyond a vague 'List of...', and omits behavioral context. For a tool with minimal structured data, the description should do more to compensate but instead adds confusion.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description lists parameters '@param class_full_name' and '@param method_name' with brief explanations, but the input schema requires only 'method_id' as a single parameter. This creates a direct contradiction: the description documents two parameters that don't exist in the schema, while the schema's one parameter ('method_id') is not mentioned at all in the description. With 0% schema description coverage, the description fails to compensate and instead misleads.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Get the code of a method by its class full name and method name' which provides a clear verb ('Get') and resource ('code of a method'), but it's vague about the exact mechanism. The title is null, so the description carries the full burden. However, it doesn't distinguish this tool from sibling tools like 'get_method_code_by_class_full_name_and_method_name' or 'get_method_code_by_full_name', which appear to serve similar purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools that seem related to retrieving method information (e.g., 'get_method_code_by_class_full_name_and_method_name', 'get_method_code_by_full_name'), there's no indication of which tool to choose in different scenarios. The lack of context or prerequisites leaves 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 full burden. It mentions retrieving information, implying a read-only operation, but doesn't disclose behavioral traits such as error handling, response format, or performance considerations. This leaves significant gaps for a tool with no structured safety hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief but could be more front-loaded; it uses two sentences with some redundancy (e.g., repeating 'call' and 'method'). While not verbose, it lacks optimal structure for quick comprehension, with room to streamline without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't explain return values beyond 'method info', leaving the agent unsure of the response format or content. For a tool with these contextual gaps, more detail is needed.
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 1 parameter and 0% schema description coverage, the description compensates by specifying the parameter 'id' as 'The id of the call', adding semantic meaning beyond the schema's generic 'Call Id'. However, it doesn't detail format or constraints, keeping the score from reaching 5.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool retrieves method information for a call referenced by a call ID, which clarifies the verb ('Get') and resource ('method info'). However, it doesn't differentiate from siblings like 'get_method_by_call_id', leaving ambiguity about how this tool's purpose differs from similar ones.
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. With siblings like 'get_method_by_call_id' and 'get_method_full_name_by_id', the description lacks context on prerequisites, exclusions, or comparative use cases, offering only basic functional intent.
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 describes a read operation ('Get the calls info'), implying it's non-destructive, but doesn't specify aspects like data format, pagination, error handling, or dependencies (e.g., requires CPG to be loaded). For a tool with no annotation coverage, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with the main purpose, followed by parameter and return annotations. It avoids unnecessary fluff, but the phrasing 'which the call is in the method' is slightly awkward and could be clearer. Overall, it's efficient but could benefit from minor structural improvements for better readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a query tool with no annotations, no output schema, and 0% schema coverage), the description is incomplete. It doesn't explain what 'calls info' includes (e.g., list of calls, details), return format, or how it relates to sibling tools. For a tool in a server with many similar methods, more context is needed to ensure proper usage without trial and error.
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 'method_full_name', explaining it as 'The full name of the method' to retrieve calls info from. Since schema description coverage is 0% (the schema only provides a title 'Method Full Name'), this compensates well by clarifying the parameter's purpose. However, it doesn't detail format (e.g., package.Class.method) or examples, leaving some ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool retrieves 'calls info by the method full name which the call is in the method', which clarifies it fetches call information within a specified method. However, it's somewhat vague about what 'calls info' entails (e.g., call details, list of calls) and doesn't differentiate from siblings like 'get_method_callees' or 'get_method_callers', which might have overlapping purposes. The purpose is understandable but lacks specificity and sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., after loading CPG), or compare to sibling tools like 'get_method_callees' or 'get_method_callers', which could retrieve similar data. Without such guidance, an agent might struggle to select the correct tool among multiple options for call-related queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states it 'gets' information (implying read-only), but doesn't disclose behavioral traits like whether it requires prior CPG loading, error handling (e.g., invalid call ID), performance considerations, or output format. 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences, front-loading the purpose. The @param and @return annotations are structured but slightly redundant with the first sentence. Every sentence adds value, though it could be more streamlined by integrating annotations into the main text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It lacks details on return value structure (beyond 'method info'), error cases, dependencies (e.g., on 'load_cpg'), and how it differs from sibling tools. For a tool in a complex CPG analysis context, this leaves significant gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal semantics: it names the parameter ('id') and clarifies it's 'The id of the call', which matches the schema's 'call_id'. However, schema description coverage is 0%, and the description doesn't explain format (e.g., string type, expected values) or constraints beyond what the schema provides. With 1 parameter and low coverage, it partially compensates but remains basic.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and target resource ('method info'), specifying it retrieves method information associated with a call ID. It distinguishes from siblings like 'get_call_code_by_id' (which gets call code) and 'get_referenced_method_full_name_by_call_id' (which gets only method name), though not explicitly. However, it doesn't fully differentiate from 'get_method_full_name_by_id' (which might get similar info by method ID).
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. It doesn't mention prerequisites (e.g., needing a loaded CPG from 'load_cpg'), exclusions, or compare to siblings like 'get_referenced_method_full_name_by_call_id' (which might return less detail). The description implies usage when you have a call ID and want method info, but lacks explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only states what the tool does ('Get the parent classes') and the return format, but doesn't mention whether it's read-only, if it requires authentication, rate limits, error handling, or what happens with invalid input. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with three brief sentences that each add value: stating the purpose, explaining the parameter, and describing the return. It's front-loaded with the core purpose first. No wasted words, though it could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 (retrieving hierarchical data), no annotations, no output schema, and 1 parameter, the description is minimally adequate. It covers the purpose, parameter meaning, and return format, but lacks behavioral context like error conditions, authentication needs, or performance characteristics that would be helpful 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?
The description adds meaningful parameter information beyond the schema. The schema has 0% description coverage (just 'Class Full Name' title), but the description explains '@param class_full_name: The fully qualified name of the class' - clarifying what format is expected. Since schema coverage is low (<50%), the description compensates well for the single parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the parent classes of a class' - a specific verb ('Get') and resource ('parent classes of a class'). It distinguishes from siblings like get_derived_classes_by_class_full_name (which gets child classes) and get_class_methods_by_class_full_name (which gets methods). However, it doesn't explicitly mention how it differs from all siblings, 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 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, error conditions, or when to choose this over similar tools like get_class_full_name_by_id or get_derived_classes_by_class_full_name. The agent must infer usage from the name and 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool checks if the plugin is running, but doesn't describe what 'running' entails (e.g., network connectivity, process status), potential error conditions, or response format. This leaves gaps in understanding the tool's behavior beyond its basic purpose.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero waste—it directly states the tool's purpose without fluff or repetition. It's appropriately sized and front-loaded, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate as a basic status check. However, it lacks details on what 'running' means or what the output might be, which could be helpful for an AI agent to interpret results. It meets the minimum viable standard but has room for improvement in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The description appropriately avoids redundant information, earning a high score for not adding unnecessary content.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Check if') and the target ('the Joern MCP plugin is running'), providing a specific verb and resource. However, it doesn't explicitly differentiate from sibling tools like 'ping' or 'get_help', which might serve similar diagnostic purposes, 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 like 'ping' or 'get_help', nor does it mention any prerequisites or exclusions. It implies usage for checking plugin status but lacks explicit context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves methods but doesn't describe what happens if the class doesn't exist, if there are access restrictions, rate limits, or the format of the returned list. For a read operation with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured: a clear purpose statement followed by parameter and return annotations. Every sentence adds value without redundancy, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a read operation with one parameter) and lack of annotations and output schema, the description is minimally adequate. It covers the purpose and parameter semantics but misses behavioral details and return value specifics. This leaves gaps for the agent to infer behavior, making it incomplete for optimal use.
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: '@param class_full_name: The fully qualified name of the class.' Since schema description coverage is 0% (the schema only provides a title and type), this compensates well by explaining what the parameter represents. However, it doesn't detail format examples or constraints, keeping it from 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 the methods of a class by its fully qualified name.' It specifies the verb ('Get') and resource ('methods of a class'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_method_code_by_class_full_name_and_method_name' or 'get_method_by_call_id', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, such as whether the class must be loaded or if there are limitations on class types. This leaves the agent without usage direction beyond the basic purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool retrieves 'help information' but doesn't specify what that includes (e.g., documentation, usage examples, server status), how it's formatted, or any limitations (e.g., authentication needs, rate limits). 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized for a simple tool and front-loads the essential information ('Get help information from joern server'). Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. However, it lacks details about what 'help information' entails and how it differs from sibling tools, leaving room for improvement in contextual understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter documentation in the description. The baseline for this scenario is 4, as the description appropriately doesn't discuss parameters that don't exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get help information') and target resource ('from joern server'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from its siblings (like 'check_connection' or 'ping'), which might also provide server-related information, 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. There's no mention of prerequisites, context for usage, or comparison to sibling tools like 'check_connection' or 'ping' that might serve similar diagnostic purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return type but doesn't cover error handling, performance, or other behavioral traits like whether the ID must exist or what happens on invalid input. The description adds minimal context 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: one for the purpose and one detailing parameters and return. It's front-loaded with the main function. However, there are minor issues like typos ('fully name' instead of 'full name') and redundant phrasing that slightly reduce efficiency.
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, no output schema, no annotations), the description is moderately complete. It covers the purpose and parameter details well but lacks information on error cases, return format nuances, or integration with sibling tools, leaving some gaps for an AI agent to infer usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the input schema, which has 0% description coverage. It specifies that the parameter 'id' (mapped to 'class_id' in schema) is a 'unique identifier of the class (typeDecl)', provides the data type 'Long int string', and gives an example format '111669149702L'. This compensates fully 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'retrieves' and the resource 'fully name of a class by its ID', making the purpose understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'get_method_full_name_by_id' or 'get_class_methods_by_class_full_name', which also retrieve class-related information but for different aspects.
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, context for selecting this over similar sibling tools (e.g., 'get_method_full_name_by_id'), or any exclusions. Usage is implied only by the purpose statement.
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 it 'gets' derived classes, implying a read-only operation, but doesn't specify whether this requires authentication, has rate limits, returns paginated results, or handles errors. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with three sentences: purpose statement, parameter documentation, and return value description. Each sentence adds value, and the structure is front-loaded with the core purpose. Minor room for improvement in flow, but very efficient.
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 (class hierarchy query), no annotations, no output schema, and 1 parameter with 0% schema coverage, the description is minimally adequate. It covers the purpose and parameter semantics but lacks behavioral details and output format explanation beyond a brief '@return' note. Completeness is borderline for safe use.
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: '@param class_full_name: The fully qualified name of the class'. With 0% schema description coverage (the schema only provides a title 'Class Full Name'), this parameter documentation in the description is essential and fully compensates for the schema gap. However, it doesn't explain format examples or constraints.
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 the derived classes of a class' - a specific verb ('Get') and resource ('derived classes'). It distinguishes from siblings like 'get_parent_classes_by_class_full_name' by focusing on derived rather than parent classes. However, it doesn't explicitly contrast with all siblings, 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 through the parameter name 'class_full_name' and the tool's name, suggesting it's for class hierarchy analysis. However, it provides no explicit guidance on when to use this tool versus alternatives like 'get_parent_classes_by_class_full_name' or 'get_class_methods_by_class_full_name', nor any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the basic operation ('retrieves a list') and return format, but lacks details on permissions, rate limits, error handling, or data freshness. 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.
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 @param and @return annotations are concise and informative, though the structure could be slightly improved by integrating the annotations more seamlessly into the main text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (1 parameter, no output schema, no annotations), the description is moderately complete. It covers the purpose, parameter semantics, and return format, but lacks behavioral details and usage guidelines. Without an output schema, it helpfully describes the return value, but overall completeness is adequate with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains the parameter 'method_full_name' with a clear definition and an example (e.g., 'com.android.nfc.NfcService$6.onReceive:void(android.content.Context,android.content.Intent)'), providing essential context that the schema alone does not offer.
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: 'Retrieves a list of methods info that are called by the specified method.' It includes a specific verb ('retrieves') and resource ('methods info'), but does not explicitly differentiate it from sibling tools like 'get_method_callers' or 'get_calls_in_method_by_method_full_name', which likely have related but distinct functions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools such as 'get_method_callers' (which might retrieve callers instead of callees) or 'get_calls_in_method_by_method_full_name' (which could be similar), leaving the agent to infer usage context without explicit direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks critical behavioral details. It mentions the conditional loading logic but doesn't disclose error handling, performance characteristics, authentication needs, or what 'successfully loaded' entails. The return value description is minimal and doesn't explain failure modes.
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 concise with three sentences that each serve a purpose: stating the action, describing the parameter, and specifying the return value. It's front-loaded with the core functionality. Minor improvements could include combining sentences for better flow.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations, no output schema, and minimal sibling context, the description provides basic operational information but lacks completeness. It covers what the tool does and the parameter meaning but misses details about CPG format, error conditions, side effects, and integration with other tools in the server.
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 and only 1 parameter, the description adds significant value by explaining that cpg_filepath is 'the path to the CPG file' and 'the filepath is absolute path'. This clarifies the parameter's purpose and format beyond what the bare schema provides, though it could elaborate on file format expectations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Loads' and resource 'CPG from a file', making the purpose understandable. It distinguishes from siblings by focusing on file loading rather than querying or connection checking. However, it doesn't explicitly differentiate from all sibling tools that might involve CPG operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage context with 'if the cpg is not loaded or the cpg is not the same as the filepath', suggesting when to use it based on current state. However, it doesn't explicitly state when to use this tool versus alternatives like check_connection or other get_* tools, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that it retrieves source code (a read operation) and mentions the CPG must be loaded, which is useful context. However, it doesn't describe error behavior (e.g., what happens if the ID doesn't exist), performance characteristics, or any limitations like rate limits or authentication needs, leaving gaps 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with three sentences: purpose statement, parameter explanation, and return value. It's front-loaded with the main purpose first. The @param and @return annotations are slightly redundant but still efficient. There's minimal waste, though it could be slightly more streamlined.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, and no output schema, the description does well by explaining the parameter and return value. However, for a tool that retrieves data from a loaded CPG, it lacks details on prerequisites (e.g., CPG must be loaded), error handling, or output format beyond 'source code'. This leaves gaps in completeness for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% description coverage. It explains that the parameter 'id' (mapped to 'code_id' in schema) is 'The unique identifier of the call node' and provides a concrete example format ('111669149702L'), clarifying it's a 'Long int string'. This compensates fully 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get the source code') and resource ('of a specific call node from the loaded CPG by the call id'), making the purpose understandable. It distinguishes from siblings like 'get_method_code_by_id' by specifying it retrieves call node source code rather than method code. However, it doesn't explicitly contrast with all similar tools like 'get_method_code_by_full_name'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'from the loaded CPG', suggesting the CPG must be loaded first (likely via 'load_cpg' sibling tool). However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_method_code_by_id' or 'get_method_code_by_full_name', nor does it specify when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the retrieval action and return format, but doesn't mention potential errors (e.g., invalid ID), performance characteristics, or authentication needs. It adds basic context about the return value format, which is helpful but not comprehensive 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 efficiently structured with a clear purpose statement followed by parameter and return documentation. Every sentence adds value: the first states what the tool does, the second explains the parameter with an example, and the third describes the return format with an example. 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?
For a single-parameter retrieval tool with no annotations and no output schema, the description is reasonably complete. It covers purpose, parameter details with examples, and return format with an example. However, it lacks error handling information and doesn't fully address behavioral aspects like performance or side effects, leaving minor gaps in completeness.
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 fully compensate. It explicitly documents the single parameter 'id' with its type (Long int string) and provides a concrete example ('111669149702L'), adding crucial meaning beyond the schema's generic 'string' type. This fully addresses the parameter semantics gap.
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 ('Retrieves') and resource ('fully qualified name of a method by its ID'), distinguishing it from siblings like get_method_code_by_id (which retrieves code) or get_method_by_call_id (which retrieves method details by call ID). The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a method ID and need its fully qualified name, but it doesn't explicitly state when to use this tool versus alternatives like get_method_full_name_by_call_id or get_method_code_by_id. No exclusions or prerequisites are mentioned, leaving usage context somewhat inferred rather than clearly defined.
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 a read-only retrieval operation ('Retrieves') and specifies the return format, which is helpful. However, it does not mention potential limitations like rate limits, authentication needs, or error conditions, leaving some behavioral aspects unclear.
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 parameter and return details in a structured format. Every sentence adds value without redundancy, making it efficient and easy to parse. The use of annotations like '@param' and '@return' enhances clarity without verbosity.
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, no output schema, no annotations), the description is largely complete: it explains the purpose, parameter, and return value. However, it could improve by addressing behavioral aspects like error handling or performance considerations, which are not covered.
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 description coverage is 0%, so the description must compensate fully. It provides a detailed parameter description with an example format for 'method_full_name' and explains what it represents, adding significant meaning beyond the bare schema. This effectively documents the single parameter's purpose and format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Retrieves') and resource ('list of methods that call the specified method'), making the purpose explicit. It distinguishes from siblings like 'get_method_callees' (which would find methods called by a method) by focusing on callers rather than callees, providing clear differentiation.
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 context by specifying the parameter format and return type, but does not explicitly state when to use this tool versus alternatives like 'get_method_callees' or other sibling tools. It provides clear input requirements but lacks explicit guidance on tool selection scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the core behavior (retrieving source code) and mentions the return type, but lacks details about error handling, performance characteristics, or data format. While adequate for basic understanding, it doesn't provide rich behavioral context beyond the fundamental operation.
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 with three sentences that each serve distinct purposes: stating the tool's function, providing usage guidelines, and explaining the parameter. While efficient, the first sentence contains a minor typo ('fully name' instead of 'full name'), slightly affecting polish.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read operation with no output schema, the description provides good coverage: it explains what the tool does, when to use it, parameter semantics, and return value. The main gap is the lack of output format details beyond 'The source code,' but given the tool's relative simplicity, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for the single parameter, the description fully compensates by providing a clear @param annotation that explains what 'method_full_name' represents, including a detailed example format. This adds significant semantic value beyond what the bare schema provides.
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 the code of a method') and resource ('by its fully name'), with explicit differentiation from the sibling tool 'get_method_code_by_class_full_name_and_method_name'. It provides a precise verb+resource combination that distinguishes it 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 Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('If you know the full name of the method') and when to use an alternative ('If you only know the full name of the class and the name of the method, you should use get_method_code_by_class_full_name_and_method_name'). This provides clear, actionable guidance for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: it performs a health check by querying the server version, and specifies the possible return outcomes (version string on success, 'Query Failed' on failure). This covers the core behavioral traits without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of just two sentences that directly explain what the tool does and what it returns. Every sentence adds essential value with zero wasted words, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is nearly complete. It explains the purpose, behavior, and return values adequately. However, it could slightly improve by mentioning any prerequisites (e.g., network connectivity) or error details beyond 'Query Failed', but this is minor for such a straightforward tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately does not discuss parameters, maintaining focus on the tool's purpose and behavior. This meets the baseline of 4 for zero-parameter tools.
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 ('checks if the Joern server is running and responsive') and the resource being accessed ('by querying its version'). It distinguishes itself from sibling tools like 'check_connection' by specifying the version query aspect, making the purpose explicit and differentiated.
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 context (to verify server responsiveness), but does not explicitly state when to use this tool versus alternatives like 'check_connection' or other diagnostic tools. It provides clear context for its purpose but lacks explicit exclusions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it returns code for all methods if multiple share the same name, and specifies the return format ('List of full name, name, signature and id of methods in the class'). However, it doesn't mention error handling, performance, or other operational details like rate limits or authentication needs, leaving some 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by usage guidelines, behavioral details, and parameter explanations. Every sentence adds value without redundancy, and the structure is logical (purpose → usage → behavior → parameters → return).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description does well: it covers purpose, usage, behavior (handling multiple methods), parameters, and return format. However, for a tool with 2 parameters and complex behavior (returning lists), it lacks details on error cases (e.g., invalid inputs, missing methods) and output structure specifics, leaving some ambiguity 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 adds meaningful semantics: '@param class_full_name: The fully qualified name of the class, like 'com.android.nfc.NfcService'' and '@param method_name: The name of the method, like 'onReceive''. These examples clarify format and usage beyond the bare schema. However, it doesn't explain constraints (e.g., case sensitivity, special characters).
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 the code of a method by its class full name and method name.' It specifies the verb ('Get'), resource ('code of a method'), and distinguishes it from siblings like 'get_method_code_by_full_name' (which uses method full name) and 'get_method_code_by_id' (which uses ID). The distinction is explicit in the first sentence.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'this tool is usually used when you don't know the full name of the method, but you know the full name of the class and the name of the method.' This directly contrasts with alternatives like 'get_method_code_by_full_name' (requires method full name) and 'get_method_code_by_id' (requires ID), making it clear when to use this tool over siblings.
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-joern MCP server](https://glama.ai/mcp/servers/sfncat/mcp-joern/badges/card.svg)](https://glama.ai/mcp/servers/sfncat/mcp-joern)

Score Badge

Copy to your README.md:

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

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/sfncat/mcp-joern'

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