An MCP server that traces and analyzes Go function call chains, dependencies, and type references. Provides tools for understanding code structure, dependencies, and impact analysis in Go projects.
The server has 5 tools with complete input schemas and descriptions, but quality varies significantly. All tools accept project path, file, and function name parameters with clear descriptions following a consistent pattern. However, there are critical issues: (1) duplicate tool definitions (func_code and get_snippet are identical), (2) generic descriptions that could be more LLM-optimized, (3) missing output schema documentation, (4) no error handling guidance, and (5) no pagination/result limiting for potentially large outputs. The tool descriptions are adequate (145-280 chars) but lack specific guidance on when to select one tool over similar ones. Parameter descriptions are present and reasonably detailed (28-85 chars), meeting the 'every param needs description' requirement, though some could be more constraint-focused (e.g., no guidance on depth parameter bounds or output size warnings).
Trace the call chain of a Go function to understand what other functions and methods it depends on. This is your primary tool for mapping execution flow and identifying critical dependencies. Use this to understand the scope of changes, find potential side effects, or trace through complex business logic. Recommended approach: Start with depth 1 to see immediate dependencies, then increase to depth 2-3 to trace the full call chain.
Generate a comprehensive dependency analysis report for a Go function. This tool traces all functions, methods, and types that your target function depends on, recursively exploring the call chain to the specified depth. Perfect for understanding the complete scope and impact of code changes. Note: This generates extensive output and may consume significant tokens. For focused exploration, start with 'ref_types' and 'called_funcs' tools first.
Get the complete, formatted source code for any Go function or method. This tool is perfect for examining specific functions you've discovered through 'called_funcs' or 'ref_types' analysis. Use this when you need to see the actual implementation details, understand function logic, or review code before making changes.
Get the complete, formatted source code for any Go function or method. This tool is perfect for examining specific functions you've discovered through 'called_funcs' or 'ref_types' analysis. Use this when you need to see the actual implementation details, understand function logic, or review code before making changes.
Duplicate tool definitions: func_code and get_snippet are identical in name, description, parameters, and function (both call GetFuncCode). This violates the composition pattern and forces LLMs to choose between identical tools, wasting reasoning cycles.
No output schema documented. Tool descriptions mention they return 'complete, formatted source code' and 'comprehensive dependency analysis report' but the MCP response structure is not specified. LLMs cannot plan downstream operations without knowing what fields to extract.
No guidance on result limits or pagination. full_report explicitly warns 'generates extensive output and may consume significant tokens' but offers no limit or pagination mechanism. If a function has 100+ dependencies, this could blow the context window.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | C | 64 | 2026-07-28+ | v2 |
| 2026-03-09 | D | 56 | - | v1 |
Discover all custom data types (structs, interfaces, type aliases) used by a function and its dependencies. This is your primary tool for understanding data structures and type relationships in Go code. Perfect for mapping out the data flow and identifying important types before diving into implementation details. Recommended workflow: Start with depth 1-2 for quick type overview, then use depth 3 for comprehensive type analysis.
Generic depth parameter lacks bounds documentation. Parameter descriptions say 'Start with 1-2' and 'use 3-4' but do not specify min/max values, maximum execution time, or what happens at depth 10 or 100. Unbounded numeric parameters let LLMs pass absurd values.
Error handling provides no recovery guidance. If a function is not found, the error message is 'Failed to find target: ...' without suggesting alternatives (e.g., 'Did you mean...?' or 'Try called_funcs to discover available functions in this file'). Pattern: recovery-guide.
Ambiguous tool naming. 'func_code', 'get_snippet', and implicitly 'full_report' all return code or analysis. Names like 'get_snippet' are generic, 'snippet' could mean a code excerpt, a template, or a saved snippet. Better: 'get_func_source', 'analyze_func_deps', 'trace_func_calls'.
No idempotency guarantees. All tools are read-only (correct), but the descriptions do not explicitly state this. LLMs should know which tools are safe to retry and which have side effects. Declarations like 'Risk: READ_ONLY' in code comments are not visible to the LLM.