{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-language-server","slug":"language-server","name":"Language Server","type":"mcp","url":"https://github.com/isaacphi/mcp-language-server","page_url":"https://unfragile.ai/language-server","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-language-server__cap_0","uri":"capability://tool.use.integration.lsp.backed.symbol.definition.retrieval.with.full.source.context","name":"lsp-backed symbol definition retrieval with full source context","description":"Bridges MCP clients to language server textDocument/definition requests, returning complete source code definitions for any symbol in a workspace. Implements a stateful LSP client that maintains workspace context and file state, translating MCP tool calls into LSP protocol messages and parsing responses into structured definition objects with file paths, line/column positions, and full source text. Supports Go, Python, TypeScript, Rust, and other LSP-compliant languages through language-agnostic LSP client abstraction.","intents":["I need to jump to the exact definition of a function or class that an AI assistant is discussing","I want an AI to understand the full implementation context of a symbol before suggesting changes","I need to verify type definitions and class hierarchies across a large codebase"],"best_for":["AI-assisted code navigation workflows where LLMs need precise symbol locations","Teams using Claude or other MCP-enabled AI assistants for code analysis","Developers working with multi-language codebases (Go, Python, TypeScript, Rust)"],"limitations":["Requires a language server to be installed and configured for the target language","Definition retrieval latency depends on language server startup time and workspace indexing","Cannot retrieve definitions for symbols in unindexed or unopened files until workspace watcher processes them","LSP server must support textDocument/definition capability (most modern servers do)"],"requires":["Go 1.16+ to build the MCP Language Server","Language server for target language (gopls for Go, pyright for Python, typescript-language-server for TypeScript, rust-analyzer for Rust)","MCP-enabled client (Claude, or other MCP-compatible AI assistant)"],"input_types":["symbol name (string)","file path (string)","line and column position (integers)"],"output_types":["structured definition object with file path, line/column range, and full source code text"],"categories":["tool-use-integration","code-navigation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_1","uri":"capability://tool.use.integration.cross.reference.discovery.with.workspace.wide.symbol.tracking","name":"cross-reference discovery with workspace-wide symbol tracking","description":"Exposes LSP textDocument/references capability through MCP, enabling AI assistants to locate all usages and references of a symbol across an entire codebase. The LSP client maintains a workspace model synchronized via file watcher events, allowing the language server to build accurate reference indexes. Returns structured reference lists with file paths, line/column positions, and surrounding context for each occurrence.","intents":["I need to understand all the places where a function or variable is used before refactoring it","I want to see the impact of renaming a symbol across the entire codebase","I need to find all implementations of an interface or abstract method"],"best_for":["Refactoring workflows where AI assistants need to understand symbol usage patterns","Impact analysis before making breaking changes to public APIs","Teams performing large-scale code migrations with AI assistance"],"limitations":["Reference discovery is only as complete as the language server's indexing (may miss dynamic references in some languages)","Workspace must be fully indexed before accurate reference results; large codebases may have multi-second indexing delays","Some languages (Python, JavaScript) have limited reference tracking for dynamically resolved symbols","Results depend on language server implementation quality; some servers may miss edge cases"],"requires":["Language server with textDocument/references support","Workspace watcher running to keep language server synchronized with file changes","Go 1.16+ for building the server"],"input_types":["symbol name (string)","file path (string)","line and column position (integers)"],"output_types":["array of reference objects, each containing file path, line/column range, and context snippet"],"categories":["tool-use-integration","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_2","uri":"capability://tool.use.integration.real.time.diagnostic.aggregation.from.language.servers","name":"real-time diagnostic aggregation from language servers","description":"Aggregates textDocument/publishDiagnostics notifications from language servers and exposes them through MCP, providing AI assistants with real-time error, warning, and info-level diagnostics for any file. The LSP client subscribes to diagnostic notifications as files are opened or modified, maintaining a current diagnostic state that reflects the language server's analysis. Diagnostics include message text, severity level, line/column ranges, and diagnostic codes for rule-based filtering.","intents":["I want to show an AI assistant the current errors and warnings in a file before asking for fixes","I need to understand what the language server thinks is wrong with my code","I want to filter diagnostics by severity (errors only, or include warnings)"],"best_for":["AI-assisted code fixing workflows where diagnostics inform the AI's suggestions","Real-time linting integration where AI assistants help resolve language server warnings","Teams using type checkers (pyright, TypeScript) that emit rich diagnostic information"],"limitations":["Diagnostics are only available for files that have been opened or watched by the language server","Diagnostic latency depends on language server analysis speed (can be 100ms-2s for large files)","Some language servers emit incomplete or duplicate diagnostics; deduplication may be needed","Diagnostic codes and messages are language-server-specific and not standardized across languages"],"requires":["Language server with diagnostic support (most modern servers emit diagnostics)","File watcher running to trigger language server analysis on file changes","Go 1.16+ for building the server"],"input_types":["file path (string)"],"output_types":["array of diagnostic objects with message, severity (error/warning/info), line/column range, and diagnostic code"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_3","uri":"capability://tool.use.integration.workspace.aware.symbol.renaming.with.multi.file.refactoring","name":"workspace-aware symbol renaming with multi-file refactoring","description":"Exposes LSP textDocument/rename capability through MCP, enabling AI assistants to rename symbols across an entire workspace with proper scope awareness. The LSP client translates rename requests into LSP protocol messages, and the language server computes all affected locations considering scope rules, shadowing, and language-specific binding semantics. Returns a workspace edit object containing all file modifications needed to complete the rename, which can be applied atomically via the apply_text_edit tool.","intents":["I want to rename a function or variable across my entire codebase safely","I need to understand all the places that will be affected by a rename before applying it","I want an AI assistant to suggest a rename and apply it across multiple files"],"best_for":["Large-scale refactoring workflows where AI assistants coordinate multi-file changes","Teams performing API redesigns where many symbols need renaming","Developers working with statically-typed languages (Go, TypeScript, Rust) with precise scope rules"],"limitations":["Rename accuracy depends on language server's scope analysis; some languages (Python, JavaScript) may have incomplete rename coverage for dynamic symbols","Rename requests block until the language server completes analysis; large codebases may have multi-second latency","Some language servers do not support renaming in all contexts (e.g., renaming imports may not be supported)","Workspace edits must be applied atomically; partial failures can leave the codebase in an inconsistent state"],"requires":["Language server with textDocument/rename support","Workspace watcher to keep language server synchronized","apply_text_edit capability to apply the resulting workspace edit","Go 1.16+ for building the server"],"input_types":["symbol name (string)","new name (string)","file path (string)","line and column position (integers)"],"output_types":["workspace edit object containing file paths and text edits needed to complete the rename"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_4","uri":"capability://tool.use.integration.type.information.and.documentation.hover.retrieval","name":"type information and documentation hover retrieval","description":"Exposes LSP textDocument/hover capability through MCP, providing AI assistants with type signatures, documentation, and contextual information for any symbol. The LSP client sends hover requests to the language server, which returns structured hover content including type information, docstrings, and markdown-formatted documentation. Enables AI assistants to understand symbol semantics without requiring full source code analysis.","intents":["I want to see the type signature of a function before asking an AI to use it","I need to understand what a parameter or return type is without reading the full definition","I want to retrieve documentation for a library function that an AI is suggesting"],"best_for":["Code completion and suggestion workflows where AI assistants need type context","Documentation lookup where AI assistants explain library APIs","Type-aware code generation where precise type information is critical"],"limitations":["Hover information quality varies by language server; some servers provide minimal documentation","Hover requests must be made for specific positions; cannot retrieve type info for all symbols in a file at once","Hover content is markdown-formatted and may contain language-server-specific formatting","Some language servers do not provide hover information for all symbol types (e.g., local variables may have limited hover data)"],"requires":["Language server with textDocument/hover support","File must be open or indexed by the language server","Go 1.16+ for building the server"],"input_types":["file path (string)","line and column position (integers)"],"output_types":["hover content object with type information, documentation, and markdown-formatted text"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_5","uri":"capability://tool.use.integration.code.lens.hint.retrieval.and.action.execution","name":"code lens hint retrieval and action execution","description":"Exposes LSP textDocument/codeLens and codeLens/resolve capabilities through MCP, enabling AI assistants to retrieve code lens hints (e.g., test counts, reference counts, implementation counts) and execute code lens actions. The LSP client requests code lenses for a file, resolves them on demand, and executes the associated commands through the language server. Enables AI assistants to trigger language-server-provided actions like running tests or navigating to implementations.","intents":["I want to see how many tests are associated with a function before asking an AI to modify it","I need to execute a code lens action (like 'run tests') through an AI assistant","I want to understand implementation counts or reference counts provided by the language server"],"best_for":["Test-driven development workflows where AI assistants need visibility into test coverage","IDE-like experiences where code lenses provide rich contextual information","Language-specific workflows (Go, TypeScript) where code lenses are heavily used"],"limitations":["Code lens support is language-server-specific and not all servers provide code lenses","Code lens execution depends on the language server's command implementation; some commands may not be executable through MCP","Code lens resolution can be expensive for large files; some servers may not support lazy resolution","Code lens actions may have side effects (e.g., running tests) that require careful coordination"],"requires":["Language server with textDocument/codeLens support","File must be open or indexed by the language server","Go 1.16+ for building the server"],"input_types":["file path (string)"],"output_types":["array of code lens objects with title, command, and arguments; execution results depend on the command"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_6","uri":"capability://tool.use.integration.batch.text.editing.with.workspace.wide.file.modifications","name":"batch text editing with workspace-wide file modifications","description":"Implements workspace/applyEdit capability through MCP, enabling AI assistants to apply multiple text edits across multiple files atomically. The tool accepts a workspace edit object (containing file paths and text edit ranges/replacements) and applies all edits through the LSP client, which coordinates with the file system and workspace watcher. Supports inserting, replacing, and deleting text at precise line/column positions, with proper handling of line ending conventions and file encoding.","intents":["I want to apply multiple code changes across different files as a single atomic operation","I need to refactor code that spans multiple files and ensure all changes are applied together","I want an AI assistant to make coordinated edits to multiple files without intermediate file saves"],"best_for":["Multi-file refactoring workflows where AI assistants coordinate changes","Code generation scenarios where AI creates or modifies multiple files","Teams using AI assistants for large-scale code transformations"],"limitations":["Edits are applied sequentially; if one edit fails, subsequent edits may not be applied (not truly atomic at filesystem level)","Large edit batches may have cumulative latency; no built-in batching optimization","File encoding and line ending handling depends on workspace configuration; may cause issues with mixed line endings","No built-in conflict detection; concurrent edits from other tools may cause data loss"],"requires":["File system write permissions for all target files","Workspace watcher running to synchronize file changes with language servers","Go 1.16+ for building the server"],"input_types":["workspace edit object containing file paths, line/column ranges, and replacement text"],"output_types":["success/failure status for each file edit; may include error messages for failed edits"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_7","uri":"capability://automation.workflow.workspace.file.change.monitoring.with.language.server.synchronization","name":"workspace file change monitoring with language server synchronization","description":"Implements a file system watcher that monitors workspace directory changes and synchronizes file state with connected language servers through LSP didOpen, didChange, and didClose notifications. The watcher uses OS-level file system events (inotify on Linux, FSEvents on macOS, etc.) to detect file creations, modifications, and deletions, and translates these into LSP protocol messages that keep language servers' workspace models current. Enables language servers to maintain accurate indexes and provide up-to-date analysis without manual file opening.","intents":["I want language servers to automatically detect when files are created, modified, or deleted","I need to ensure that language server analysis stays synchronized with the file system","I want to avoid manually opening files in the language server to trigger analysis"],"best_for":["Continuous analysis workflows where language servers need real-time file state","Large codebases where manual file management is impractical","Teams using AI assistants that make file modifications and expect immediate language server feedback"],"limitations":["File watcher may miss rapid file changes if they occur faster than the watcher can process them","Large workspaces with thousands of files may have high memory overhead for the watcher","Some file systems (network drives, certain cloud storage) may have unreliable file change notifications","Watcher does not track file renames; renames are treated as delete + create, which may confuse language servers"],"requires":["OS-level file system event support (inotify on Linux, FSEvents on macOS, ReadDirectoryChangesW on Windows)","File system permissions to read and monitor workspace directory","Go 1.16+ for building the server"],"input_types":["workspace directory path (string)"],"output_types":["LSP didOpen, didChange, didClose notifications sent to language servers; no direct output to MCP clients"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_8","uri":"capability://tool.use.integration.multi.language.lsp.client.with.protocol.abstraction","name":"multi-language lsp client with protocol abstraction","description":"Provides a unified LSP client implementation that abstracts away language-specific differences and manages communication with multiple language servers simultaneously. The client handles LSP protocol details (JSON-RPC message formatting, request/response correlation, notification handling) and maintains separate connections to language servers for different languages (gopls, pyright, typescript-language-server, rust-analyzer). Implements proper error handling, request timeouts, and connection lifecycle management for each language server.","intents":["I want to work with multiple programming languages in a single codebase without managing separate language server connections","I need a unified interface to query semantic information across different languages","I want to handle language server failures gracefully without disrupting the entire system"],"best_for":["Polyglot codebases with multiple programming languages","Teams using AI assistants that need to understand code across language boundaries","Developers building language-agnostic code analysis tools"],"limitations":["Each language server must be installed and configured separately; no automatic language server discovery","Language server startup time adds latency to initial requests; large workspaces may take 5-10 seconds to fully initialize","LSP protocol version differences between language servers may cause compatibility issues","No built-in fallback if a language server crashes; manual restart required"],"requires":["Language servers installed for each language (gopls, pyright, typescript-language-server, rust-analyzer, etc.)","Go 1.16+ for building the server","mcp-go library for MCP protocol implementation"],"input_types":["language identifier (string: 'go', 'python', 'typescript', 'rust', etc.)","LSP requests (various types depending on the request)"],"output_types":["LSP responses (various types depending on the request)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-language-server__cap_9","uri":"capability://tool.use.integration.mcp.tool.registration.and.request.routing","name":"mcp tool registration and request routing","description":"Implements the MCP server component that registers semantic tools (read_definition, find_references, rename_symbol, etc.) and routes incoming MCP tool calls to the appropriate LSP client methods. The MCP server uses mcp-go library to handle MCP protocol messages, parses tool arguments, translates them into LSP requests, and returns results in MCP-compatible format. Provides error handling and response formatting for each tool, ensuring consistent interfaces across all semantic capabilities.","intents":["I want MCP-enabled AI assistants to access semantic code analysis tools through a standard interface","I need to expose language server capabilities to Claude or other MCP clients","I want to handle tool invocation errors gracefully and return meaningful error messages"],"best_for":["AI assistants (Claude, etc.) that support MCP protocol","Teams building custom MCP servers for code analysis","Developers integrating language server capabilities into AI workflows"],"limitations":["MCP protocol overhead adds ~50-100ms latency per tool call compared to direct LSP calls","Tool argument parsing depends on correct schema definition; malformed arguments will cause tool failures","No built-in caching of tool results; repeated queries will re-execute LSP requests","MCP clients must support the specific tool schemas; incompatible clients cannot use the tools"],"requires":["mcp-go library for MCP protocol implementation","MCP-enabled client (Claude, or other MCP-compatible AI assistant)","Go 1.16+ for building the server"],"input_types":["MCP tool call messages with tool name and arguments (JSON)"],"output_types":["MCP tool result messages with structured data or error responses (JSON)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":30,"verified":false,"data_access_risk":"high","permissions":["Go 1.16+ to build the MCP Language Server","Language server for target language (gopls for Go, pyright for Python, typescript-language-server for TypeScript, rust-analyzer for Rust)","MCP-enabled client (Claude, or other MCP-compatible AI assistant)","Language server with textDocument/references support","Workspace watcher running to keep language server synchronized with file changes","Go 1.16+ for building the server","Language server with diagnostic support (most modern servers emit diagnostics)","File watcher running to trigger language server analysis on file changes","Language server with textDocument/rename support","Workspace watcher to keep language server synchronized"],"failure_modes":["Requires a language server to be installed and configured for the target language","Definition retrieval latency depends on language server startup time and workspace indexing","Cannot retrieve definitions for symbols in unindexed or unopened files until workspace watcher processes them","LSP server must support textDocument/definition capability (most modern servers do)","Reference discovery is only as complete as the language server's indexing (may miss dynamic references in some languages)","Workspace must be fully indexed before accurate reference results; large codebases may have multi-second indexing delays","Some languages (Python, JavaScript) have limited reference tracking for dynamically resolved symbols","Results depend on language server implementation quality; some servers may miss edge cases","Diagnostics are only available for files that have been opened or watched by the language server","Diagnostic latency depends on language server analysis speed (can be 100ms-2s for large files)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.45,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:03.577Z","last_scraped_at":"2026-05-03T14:00:15.503Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=language-server","compare_url":"https://unfragile.ai/compare?artifact=language-server"}},"signature":"lq6FCdAUscYqA/197DTuBcXWLUYp0z88suGwCCM24T/r4jmDcT0WKuAgDjhze3pSb+oNfcqfKT5YCI9j4s+JBg==","signedAt":"2026-06-20T20:45:18.378Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/language-server","artifact":"https://unfragile.ai/language-server","verify":"https://unfragile.ai/api/v1/verify?slug=language-server","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}