Atlas / MCP servers / professioneit / lsp-mcp-server

lsp-mcp-serverSAFE

Name: lsp-mcp-server
Author: professioneit

mcp/professioneit/lsp-mcp-server

MCP server by professioneit · llm tools · mcp · mcp server · Audited 2026-10-12

An MCP (Model Context Protocol) server that bridges Claude Code to Language Server Protocol (LSP) servers, enabling semantic code intelligence capabilities.

Verdict

SAFE

Grade

Trust score

89 /100

Exposed tools

29 25r · 4w · 0d

Transport

stdio

License

MIT

Stars

Overview

From the repository's own README, as read at the audited commit. Badges and raw HTML are left out.

An MCP (Model Context Protocol) server that bridges Codex, Claude Code, and other MCP clients to Language Server Protocol (LSP) servers, enabling semantic code intelligence capabilities.

Overview

lsp-mcp-server acts as a bridge between MCP clients and language servers, providing powerful code intelligence features:

Go to Definition - Navigate to where symbols are defined
Find References - Find all usages of a symbol across the workspace
Hover Information - Get type information and documentation
Code Completion - Get intelligent code suggestions
Diagnostics - Access errors, warnings, and hints from the language server
Symbol Search - Search for symbols in documents or across the workspace
Rename - Safely rename symbols across the entire codebase
Code Actions - Apply quick fixes, refactorings, and organize imports
Call Hierarchy - See who calls a function and what it calls
Type Hierarchy - Explore class inheritance and interface implementations
Format Document - Format code using the language server's formatter
Smart Search - Comprehensive symbol analysis in a single call
File Analysis - Explore imports, exports, and file relationships

┌─────────────┐      ┌──────────────────┐      ┌───────────────────┐
│ MCP client  │────▶│  lsp-mcp-server  │────▶│ Language Servers  │
│ Codex/Claude│◀────│   (this tool)    │◀────│ (TypeScript, etc) │
└─────────────┘      └──────────────────┘      └───────────────────┘
stdio              stdio/JSON-RPC            stdio

Features

29 MCP Tools for comprehensive code intelligence
10 Languages Supported out of the box:
TypeScript / JavaScript
Python
Rust
Go
C / C++
Ruby
PHP
Elixir
Kotlin
Java
Multi-root Workspace - Proper monorepo support with per-workspace server instances
Push-based Diagnostics - Real-time error/warning caching from language servers

Read from source at commit 0619af6c19f9OBSERVED · 2026-10-12

Connect

Built from this server's own package name, version and transport as found in its source — not copied from anyone's documentation, so it cannot drift against a page we do not control.

claude-code

claude mcp add lsp-mcp-server -- npx -y [email protected]

claude-desktop

{
  "mcpServers": {
    "lsp-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "[email protected]"
      ]
    }
  }
}

Exposed tools (29)

25 read · 4 write · 0 destructive.

Tool	Risk	Description
`lsp_call_hierarchy`	read	Trace function calls: who calls this function (incoming) and what it calls (outgoing). Essential for understanding code flow and assessing impact before modifying a function.
`lsp_code_actions`	read	Get quick fixes and refactoring suggestions at a position. Use to auto-fix errors, organize imports, extract functions, or apply other automated transformations. Set apply=true to execute an action.
`lsp_completions`	read	Get intelligent code completion suggestions at a position. Returns available methods, properties, variables, and types that are valid in that context. More accurate than text-based completion.
`lsp_diagnostics`	read	Get compiler errors, warnings, and hints for a file. Use after making changes to check for type errors, missing imports, or other issues. Diagnostics come from the language server, published or, for servers such as TypeScript 7, requested.
`lsp_document_highlights`	read	Find all occurrences of the symbol at a position within the same file, classified as text/read/write. Faster and more local than lsp_find_references when you only care about one file (e.g., quick local rename preview or read-vs-write analysis).
`lsp_document_symbols`	read	Get a structured outline of a file: all functions, classes, interfaces, and variables with their types and relationships. Faster and more accurate than reading and parsing the file yourself.
`lsp_file_exports`	read	Get the public API surface of a file: top-level functions, classes, interfaces, and variables with their type signatures. Use to understand what a module exposes without reading the entire file.
`lsp_file_imports`	read	Get all imports/dependencies of a file. Shows what modules this file depends on, including ES modules, CommonJS require(), and dynamic imports. Use to understand file dependencies.
`lsp_find_implementations`	read	Find all concrete implementations of an interface, abstract class, or abstract method. Use to understand how an abstraction is actually used in practice.
`lsp_find_references`	read	Find every usage of a symbol across the codebase. Use before renaming or deleting to understand impact. More complete than grep—finds semantic matches, not just text.
`lsp_find_symbol`	read	Find a symbol by name alone—no file path or position needed. Returns the definition location plus full context (type info, references, call hierarchy). Use when you know a symbol name but not where it is defined.
`lsp_folding_ranges`	read	Get the foldable regions of a file (functions, classes, blocks, imports, comments). Use as a quick structural overview before reading specific sections.
`lsp_format_document`	read	Format a file according to project style settings (prettier, eslint, etc.). Use after making edits to ensure consistent formatting. Set apply=true to write changes.
`lsp_goto_definition`	read	Find where a function, class, or variable is defined. More accurate than grep—handles aliases, re-exports, and overloads correctly. Returns file path, line, and column of the definition.
`lsp_goto_type_definition`	read	Find the type that defines a variable, parameter, or return value. Use when you have a variable and want to see its interface/class definition, not where the variable itself is declared.
`lsp_hover`	read	Get the type signature and documentation for any symbol. Use to understand what a function accepts/returns or what type a variable has, without reading its implementation.
`lsp_index_files`	read	Open a batch of files so language servers begin publishing diagnostics for them. Required warm-up before lsp_workspace_diagnostics (which only sees opened files) and before lsp_related_files imported_by. Use a small targeted set rather than the whole workspace.
`lsp_inlay_hints`	read	Get inferred type annotations and parameter-name hints for a range of code. Reveals variable types, return types, and named-parameter mappings without one hover per identifier. Ideal for understanding heavily inferred code (TypeScript const/let, Rust let, etc.) at scale.
`lsp_related_files`	read	Find files connected to a given file: what it imports and what imports it. Use to understand a file\
`lsp_rename`	write	Rename a symbol across the entire codebase safely. Handles all references, imports, and re-exports. Use dry_run=true (default) to preview changes before applying. More reliable than find-and-replace.
`lsp_selection_range`	read	Get the chain of semantic ranges enclosing a position — the expression, then its statement, then its block, up to the file. Use to pick the right range for lsp_code_actions (e.g.,
`lsp_server_status`	read	Check which language servers are running and their state. Use to verify LSP is available before analysis or to debug connection issues.
`lsp_signature_help`	read	Get parameter hints for a function call. Use when you need to know what arguments a function expects and their types, especially for overloaded functions.
`lsp_smart_search`	read	Get comprehensive information about a symbol in one call: type signature, definition location, all references, implementations, and call hierarchy. Use when you need full context about something instead of making multiple separate queries.
`lsp_start_server`	write	Start a language server manually for a workspace. Usually not needed—servers auto-start when you use other LSP tools. Use only when you need explicit control over server lifecycle.
`lsp_stop_server`	write	Stop a running language server to free resources. Servers auto-stop after idle timeout, so manual stop is rarely needed.
`lsp_type_hierarchy`	read	Explore inheritance: find parent classes/interfaces (supertypes) and child classes/implementations (subtypes). Use to understand class relationships before modifying a base class or interface.
`lsp_workspace_diagnostics`	read	Get all errors and warnings across the entire project—no file path needed. Use during initial analysis to find problems or after changes to check overall project health. Only includes files opened in this session.
`lsp_workspace_symbols`	write	Find any function, class, interface, or type by name—no file path needed. Start here when exploring a codebase or locating where something is defined. Supports fuzzy matching.

Trust audit

SAFEgrade B · trust 89/100 Nothing in the source contradicts what it says it does. Grade A is reserved for packages that have also passed the behavioural sandbox.

Layer	What it checks	Result
L0	Provenance & inventory	PASS
L1	Static analysis of the code	PASS
L2	Instruction surface (what it tells the agent)	PASS
L3	Class-specific surface	PASS
L4	Behavioural (sandbox)	SKIPPED