IntelliJ IDE plugin providing MCP tools for code analysis, symbol navigation, and language features via LSP integration
MCP Idea LSP defines 4 code analysis tools with strong technical descriptions and comprehensive input schemas. Tool naming is verb-based and clear (find_symbol_definition, find_symbol_references, get_hover_info, get_symbols_in_file). Descriptions are detailed and explain WHEN to use each tool, which exceeds baseline. However, there are critical gaps: (1) NO documented output schemas visible in the code, LLMs cannot know what fields to expect; (2) error handling returns Response objects but the structure is not documented; (3) parameters lack granular constraints (enums, ranges, regexes) even though they accept specific values; (4) some parameter descriptions are verbose but lack explicit format/constraint guidance for LLMs. The code shows strong engineering (error categorization with actionable hints, null safety, language support validation), but the tool definitions lack the machine-readable structure that makes LLMs self-correct effectively. This is a B-/C+ server: good intent, incomplete schema documentation.
Go to symbol definition. Find where declared. Use to understand symbol without reading entire file(s). 1. Position-only: filePath + position (cursor at symbol) 2. Name-only: symbolName (searches project-wide) 3. Hybrid: all three parameters (disambiguation) Use `get_symbols_in_file` tool to find correct position. Params: - symbolName: "User" or "ClassName.methodName" - filePath (optional without position) - position (required with filePath) Supported: Java, Kotlin, Python, JavaScript, TypeScript
Find all usages of symbol. Returns grouped results with insights. Use when: need impact analysis, find callers, refactoring prep, usage patterns Returns: - Grouped by usage type (method_call, field_read, field_write, etc) - Insights: "Primary usage in UserController (15 calls)", "No test usage - add tests", "3 deprecated usages" - Data flow context: "passed as argument", "returned from method", "used in condition" - Each ref has: location, usage type, test/deprecated flags, surrounding code Usage types: method_call, static_method_call, getter_call, setter_call, field_read, field_write, field_increment, constructor_call, type_reference, method_override Parameter combinations 1. Position: filePath + position (finds symbol at cursor) 2. Name: symbolName only (project-wide search) 3. Both: disambiguation when multiple matches Params: - symbolName: name to find - filePath (optional without position) - position (required with filePath): find at specific location - includeDeclaration (default false): include original declaration Supported languages: Java, Kotlin, Python, JavaScript, TypeScript
Get type info and docs at position. Use when: need type info, read docs, check signatures, see modifiers Returns: - Basic: name, type, signature, modifiers, javaDoc, jsDoc - Classes: superTypes, implementedBy (interfaces) - Methods: overriddenBy, calledByCount, complexity, throwsExceptions - Extracted tags: @since, @see, @deprecated message - Fields: usage count Params: - filePath: relative to project - position: char offset (use get_symbols_in_file startOffset) Workflow: get_symbols_in_file -> use startOffset -> hover for details Supported languages: Java, Kotlin, Python, JavaScript, TypeScript
No documented output schemas for any tool. LLMs cannot know what fields are returned, making it impossible to chain tool calls or extract required data for downstream operations. E.g., find_symbol_definition likely returns a list of definition objects with fields like 'filePath', 'position', 'type', etc., but none of this is visible in the tool definition.
Parameters lack formal constraints. 'symbolName' accepts both simple names ('User') and qualified names ('ClassName.methodName'), and 'position' is an integer offset, but LLMs have no machine-readable bounds, enums, or format hints. The descriptions are prose but lack regex patterns, min/max, or explicit format specs.
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | C | 63 | <=2025-11-25 | v2 |
| 2026-03-09 | F | 48 | - | v1 |
Extract symbols from a file. Understands code for complex file queries. symbolTypes: class, interface, enum, function, method, field, property, variable, constant, type_alias, union_type, generic_type, namespace, package, import, comment, constructor, getter, setter, operator, annotation, decorator Parameters: - filePath (required): relative to project root - symbolTypes (default: all): Filter the returned symbols to include these types - hierarchical (default: true): true=nested, false=flat list (use false for position searches) - includeImports (default: false): include import statements - includePrivate (default: true): include private members - includeGenerated (default: false): include synthetic code - maxDepth (default: 10): max nesting for hierarchical view Returns: [{name, kind, startOffset, endOffset, visibility, modifiers, signature, children}] Each symbol has exact offsets for use with other tools. Supported: Java, Kotlin, Python, JavaScript, TypeScript
Error handling returns Response objects with actionable guidance (e.g., 'Provide a symbolName parameter'), but the error response structure is not formally documented. LLMs cannot parse error details programmatically, only read prose hints. Should return typed error objects with code, message, and recovery actions.
Parameter 'symbolTypes' in get_symbols_in_file is an array of strings with no enum constraint. The description lists valid types ('class', 'interface', 'enum', 'function', etc.), but as prose, not a formal enum. LLMs may hallucinate invalid types like 'struct' or 'protocol'.
Supported languages are enumerated in descriptions ('Java, Kotlin, Python, JavaScript, TypeScript') but not as formal constraints on parameters. If a tool is called with an unsupported file type, the error message is good, but there's no way for LLMs to validate proactively.
Parameter ranges are not documented. 'position' is a character offset, but what are the bounds? 0 to file length? What about negative values or beyond the file? 'maxDepth' in get_symbols_in_file defaults to 10, but is there a minimum? Can it be 0 or 1000? LLMs need explicit ranges.