agent-lsp
The most complete MCP server for language intelligence. 56 tools, 30 CI-verified languages, 22 agent workflows. Single Go binary.
AI agents make incorrect code changes because they can't see the full picture: who calls this function, what breaks if I rename it, does the build still pass. Language servers have the answers, but existing MCP bridges either cold-start on every request or expose raw tools that agents use incorrectly.
agent-lsp is a stateful runtime over real language servers. It indexes your workspace once, keeps the index warm, and adds a skill layer that encodes correct multi-step operations so they actually complete.
How the pieces fit together: LSP (Language Server Protocol) is how editors get code intelligence — completions, diagnostics, go-to-definition. MCP (Model Context Protocol) is the standard way AI tools like Claude Code discover and call external tools. agent-lsp bridges the two: language server intelligence, accessible to AI agents.
How it works
One agent-lsp process manages your language servers. Point your AI at ~/code/. It routes .go to gopls, .ts to typescript-language-server, .py to pyright. No reconfiguration when you switch projects. The session stays warm across files, packages, and repositories.
Tested, not assumed
Every other MCP-LSP implementation lists supported languages in a config file. None of them run the actual language server in CI to verify it works.
agent-lsp CI runs 30 real language servers against real fixture codebases on every push: Go, Python, TypeScript, Rust, Java, C, C++, C#, Ruby, PHP, Kotlin, Swift, Scala, Zig, Lua, Elixir, Gleam, Clojure, Dart, Terraform, Nix, Prisma, SQL, MongoDB, and more. When we say "works with gopls," that's a verified, automated claim, not a hope.
Speculative execution
Simulate changes in memory before writing to disk. No other MCP-LSP implementation has this.
simulate_edit_atomic previews the diagnostic impact of any edit. You see exactly what breaks before the file is touched. simulate_chain evaluates a sequence of dependent edits (rename a function, update all callers, change the return type) and reports which step first introduces an error.
8 speculative execution tools. See docs/speculative-execution.md for the full workflow.
Token savings
Structured LSP responses use 5-34x fewer tokens than grep/read on the same tasks. On HashiCorp Consul (319K lines), a blast-radius analysis uses 17.7MB via grep vs 841KB via LSP, reducing 5,534 tool calls to 119. Savings scale with codebase size. See docs/token-savings.md for the full experiment across five codebases.
Persistent daemon mode
Python and TypeScript projects need minutes of background indexing before get_references works. agent-lsp automatically spawns a persistent daemon broker that survives between sessions, so the workspace stays indexed. First session: daemon starts and indexes (~10s for FastAPI). Subsequent sessions: instant connection to the warm daemon. Auto-exits after 30 minutes of inactivity. Go, Rust, and other fast-indexing languages bypass this entirely (zero overhead).
Phase enforcement
Skills tell agents the correct order of operations. Phase enforcement makes the runtime block violations instead of trusting the agent to follow instructions.
When an agent activates a skill, every tool call is checked against the current phase's permissions. Calling apply_edit during blast-radius analysis doesn't silently proceed; it returns an error with specific recovery guidance ("complete the blast_radius phase first, allowed tools: [get_change_impact, get_references]"). Phases advance automatically as the agent calls tools from later phases.
No other MCP tool provider enforces workflow ordering at runtime. See docs/phase-enforcement.md.
Works with
AI Tool | Transport | Config |
stdio |
| |
stdio |
| |
stdio |
| |
stdio |
| |
Any MCP client | HTTP+SSE |
|
Skills
Raw tools get ignored. Skills get used. Each skill encodes the correct tool sequence so workflows actually happen without per-prompt orchestration instructions. Skills are available as AgentSkills slash commands and as MCP prompts via prompts/list / prompts/get for any MCP client.
See docs/skills.md for full descriptions and usage guidance.
Before you change anything
Skill | Purpose |
| Blast-radius analysis before touching a symbol or file |
| Find all concrete implementations of an interface |
| Detect zero-reference exports before cleanup |
Editing safely
Skill | Purpose |
| Speculative preview before disk write; before/after diagnostic diff; surfaces code actions on errors |
| Test changes in-memory without touching the file |
| Edit a named symbol without knowing its file or position |
| Safe editing of exported symbols, finds all callers first |
|
|
Understanding unfamiliar code
Skill | Purpose |
| "Tell me about this symbol": hover + implementations + call hierarchy + references in one pass |
| Deep-dive Code Map for a symbol or file: type info, call hierarchy, references, source |
| Three-tier documentation: hover → offline toolchain → source |
| Find all usages of a library symbol across consumer repos |
| File-scoped symbol list, usage search, and type info |
After editing
Skill | Purpose |
| Diagnostics + build + tests after every edit |
| Apply quick-fix code actions for all diagnostics in a file |
| Find and run only tests that cover an edited file |
| Format a file or selection via the language server formatter |
Generating code
Skill | Purpose |
| Trigger server-side code generation (interface stubs, test skeletons, mocks) |
| Extract a code block into a named function via code actions |
Full workflow
Skill | Purpose |
| End-to-end refactor: blast-radius → preview → apply → verify → test |
| Full code quality audit: dead symbols, test coverage, error handling, doc drift |
Related MCP server: uacos
Docker
Stdio mode (MCP client spawns the container directly):
# Go
docker run --rm -i -v /your/project:/workspace ghcr.io/blackwell-systems/agent-lsp:go go:gopls
# TypeScript
docker run --rm -i -v /your/project:/workspace ghcr.io/blackwell-systems/agent-lsp:typescript typescript:typescript-language-server,--stdio
# Python
docker run --rm -i -v /your/project:/workspace ghcr.io/blackwell-systems/agent-lsp:python python:pyright-langserver,--stdioHTTP mode (persistent service, remote clients connect over HTTP+SSE):
docker run --rm \
-p 8080:8080 \
-v /your/project:/workspace \
-e AGENT_LSP_TOKEN=your-secret-token \
ghcr.io/blackwell-systems/agent-lsp:go \
--http --port 8080 go:goplsImages run as a non-root user (uid 65532) by default. Set AGENT_LSP_TOKEN via environment variable, never --token on the command line. Images are also mirrored to Docker Hub (blackwellsystems/agent-lsp). See DOCKER.md for the full tag list, HTTP mode setup, and security hardening options.
Setup
Step 1: Install agent-lsp
curl -fsSL https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.sh | shmacOS / Linux
brew install blackwell-systems/tap/agent-lspWindows
# PowerShell (no admin required)
iwr -useb https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.ps1 | iex
# Scoop
scoop bucket add blackwell-systems https://github.com/blackwell-systems/agent-lsp
scoop install blackwell-systems/agent-lsp
# Winget
winget install BlackwellSystems.agent-lspAll platforms
# pip
pip install agent-lsp
# npm
npm install -g @blackwell-systems/agent-lsp
# Go install
go install github.com/blackwell-systems/agent-lsp/cmd/agent-lsp@latestStep 2: Install language servers
Install the servers for your stack. Common ones:
Language | Server | Install |
TypeScript / JavaScript |
|
|
Python |
|
|
Go |
|
|
Rust |
|
|
C / C++ |
|
|
Ruby |
|
|
Full list of 30 supported languages in docs/language-support.md.
Step 3: Verify setup
agent-lsp doctorProbes each configured language server and reports capabilities. Fix any failures before proceeding. See language support for install commands and server-specific notes.
Step 4: Configure your AI tool
agent-lsp initDetects language servers on your PATH, asks which AI tool you use, and writes the correct MCP config. For CI or scripted use: agent-lsp init --non-interactive.
The generated config looks like:
{
"mcpServers": {
"lsp": {
"type": "stdio",
"command": "agent-lsp",
"args": [
"go:gopls",
"typescript:typescript-language-server,--stdio",
"python:pyright-langserver,--stdio"
]
}
}
}Each arg is language:server-binary (comma-separate server args).
Step 5: Install skills
git clone https://github.com/blackwell-systems/agent-lsp.git /tmp/agent-lsp-skills
cd /tmp/agent-lsp-skills/skills && ./install.sh --copySkills are prompt files copied into your AI tool's configuration. --copy means the clone can be safely deleted afterward.
Skills are also available as MCP prompts: any MCP client can discover them via prompts/list and retrieve full workflow instructions via prompts/get, with no manual installation required. The install.sh path is for AgentSkills-compatible clients (Claude Code slash commands).
Skills are multi-tool workflows that encode reliable procedures: blast-radius check before edit, speculative preview before write, test run after change. See docs/skills.md for the full list.
Step 6: Start working
Your AI agent calls tools automatically. The first call initializes the workspace:
start_lsp(root_dir="/your/project")This is what the agent does, not something you type. Then use any of the 56 tools. The session stays warm; no restart needed when switching files.
What's unique about agent-lsp
Capability | Details |
Tools | 56 |
Languages (CI-verified) | 30 — end-to-end integration tests on every push |
Agent workflows (skills) | 22 — named multi-step procedures, discoverable via MCP |
Speculative execution | 8 tools — simulate changes before writing to disk |
Phase enforcement | 4 skills — runtime blocks out-of-order tool calls with recovery guidance |
Connection model | persistent — warm index across files and projects |
Call hierarchy | ✓ — single tool, direction param |
Type hierarchy | ✓ — CI-verified |
Cross-repo references | ✓ — multi-root workspace |
Auto-watch | ✓ — always-on, debounced file watching |
HTTP+SSE transport | ✓ — bearer token auth, non-root Docker |
Distribution | single Go binary — 10 install channels |
Use Cases
Multi-project sessions: point your AI at
~/code/, work across any project without reconfiguringPolyglot development: Go backend + TypeScript frontend + Python scripts in one session
Large monorepos: one server handles all languages, routes by file extension
Code migration: refactor across repos with full cross-repo reference tracking
CI pipelines: validate against real language server behavior
Niche language stacks: Gleam, Elixir, Prisma, Zig, Clojure, Nix, Dart, Scala, MongoDB, all CI-verified
Multi-Language Support
30 languages, CI-verified end-to-end against real language servers on every CI run. No other MCP-LSP implementation tests a single language in CI.
Go, Python, TypeScript, Rust, Java, C, C++, C#, Ruby, PHP, Kotlin, Swift, Scala, Zig, Lua, Elixir, Gleam, Clojure, Dart, Terraform, Nix, Prisma, SQL, MongoDB, JavaScript, YAML, JSON, Dockerfile, CSS, HTML.
See docs/language-support.md for the full coverage matrix.
Tools
56 tools covering navigation, analysis, refactoring, speculative execution, and session lifecycle. All CI-verified.
See docs/tools.md for the full reference with parameters and examples.
Further reading
Documentation
Tools reference — full tool reference with parameters and examples
Skills reference — skill reference: workflows, use cases, and composition
Language support — language coverage matrix
Architecture — system design and internals
Speculative execution — simulate-before-apply workflows
LSP conformance — LSP 3.17 spec coverage
Docker — Docker tags, compose, and volume caching
Contributing
CI notes — CI quirks and test harness details
Distribution — install channels and release pipeline
Development
git clone https://github.com/blackwell-systems/agent-lsp.git
cd agent-lsp && go build ./...
go test ./... # unit tests
go test ./... -tags integration # integration tests (requires language servers)Library Usage
The pkg/lsp, pkg/session, and pkg/types packages expose a stable Go API for using agent-lsp's LSP client directly without running the MCP server.
import "github.com/blackwell-systems/agent-lsp/pkg/lsp"
client := lsp.NewLSPClient("gopls", []string{})
client.Initialize(ctx, "/path/to/workspace")
defer client.Shutdown(ctx)
locs, err := client.GetDefinition(ctx, fileURI, lsp.Position{Line: 10, Character: 4})See docs/architecture.md for the full package API.
License
MIT
Available Tools
50 toolsadd_workspace_folderA
Add a directory to the LSP workspace, enabling cross-repo references, definitions, and diagnostics. Useful when working across a library and its consumers — after adding the consumer repo, get_references on a library function returns call sites in both repos. Requires start_lsp to have been called first. Language servers that support multi-root workspaces (gopls, rust-analyzer, typescript-language-server) will re-index the new folder automatically.
Inputs: path (required).
apply_editA
Apply an edit to a file. Two modes: (1) WorkspaceEdit mode — pass workspace_edit with positional changes returned by rename_symbol or format_document; (2) Text-match mode — pass file_path + old_text + new_text to find and replace text without needing line/column positions. Text-match tries exact match first, then whitespace-normalised line match (handles indentation differences). Use text-match when AI-generated positions would be imprecise.
Inputs: new_text, old_text, file_path, workspace_edit.
call_hierarchyB
Show call hierarchy for a symbol at a position. Returns callers (incoming), callees (outgoing), or both depending on the direction parameter. Direction defaults to "both". Use this to understand code flow -- which functions call this function and which functions it calls.
Inputs: line (required), column (required), file_path (required), direction, +1 more.
close_documentB
Close a file in the LSP server. Use this tool when you're done with a file to free up resources and reduce memory usage. It's good practice to close files that are no longer being actively analyzed, especially in long-running sessions or when working with large codebases.
Inputs: file_path (required).
commit_sessionA
Commit a simulation session. With apply=true, writes changes to disk and notifies LSP servers. With apply=false, returns a unified diff patch. Use after evaluate_session confirms the changes are safe.
Inputs: session_id (required), apply, target.
create_simulation_sessionA
Create a new speculative code session for simulating edits without committing to disk. Returns a session ID. Baseline diagnostics are captured lazily on first edit per file. Use this to explore what-if scenarios before applying changes.
Inputs: language (required), workspace_root (required).
destroy_sessionA
Destroy a simulation session and release all resources. Call this after commit or discard to clean up. Sessions in terminal states (committed, discarded, destroyed) cannot be reused.
Inputs: session_id (required).
detect_lsp_serversA
Scan a workspace directory for source languages and check PATH for the corresponding LSP server binaries. Returns detected workspace languages (ranked by prevalence), installed servers with their paths, and a suggested_config array ready to paste into the agent-lsp MCP server args. Use this to set up agent-lsp for a new project or verify your configuration.
Inputs: workspace_dir (required).
did_change_watched_filesA
Notify the language server that files have changed on disk outside the editor (workspace/didChangeWatchedFiles). Use this after writing files directly to disk so the server refreshes its caches. Change types: 1=created, 2=changed, 3=deleted. File URIs must use the file:/// scheme.
Inputs: changes (required).
discard_sessionA
Discard a simulation session and revert all in-memory changes by restoring baseline content. Use when simulation results show the changes would introduce errors.
Inputs: session_id (required).
evaluate_sessionA
Evaluate a simulation session by comparing current diagnostics against baselines. Returns errors introduced, errors resolved, net delta, and confidence (high for file scope, eventual for workspace). Use after simulate_edit to assess impact before committing.
Inputs: session_id (required), scope, timeout_ms.
execute_commandA
Execute a workspace command via LSP. Commands are server-defined identifiers returned by code actions (in the command field of a CodeAction). Use this after get_code_actions to trigger a server-side operation such as applying a refactoring, generating code, or running a server-specific action. Returns the server-defined result or null.
Inputs: command (required), arguments.
format_documentA
Get formatting edits for an entire document via LSP. Returns TextEdit[] describing the changes needed to format the file according to the language server's style rules. The edits are returned for inspection — they are NOT applied automatically. Use this to see what formatting changes a formatter would make.
Inputs: file_path (required), tab_size, language_id, insert_spaces.
format_rangeA
Get formatting edits for a specific range within a document via LSP (textDocument/rangeFormatting). Returns TextEdit[] for the selected lines/characters only. Use this when you want to format a function, block, or selection rather than the entire file. The edits are NOT applied automatically.
Inputs: end_line (required), file_path (required), end_column (required), start_line (required), +4 more.
get_change_impactA
Enumerate all exported symbols in the specified files, resolve their references across the workspace, and partition callers into test vs non-test. Returns affected_symbols (name, file, line), test_callers (with enclosing test function names), and non_test_callers. Use before editing a file to understand blast radius. Set include_transitive=true to surface second-order callers (callers of callers).
Inputs: changed_files (required), include_transitive.
get_code_actionsA
Get code actions for a specific range in a file. Use this tool to obtain available refactorings, quick fixes, and other code modifications that can be applied to a selected code range. Examples include adding imports, fixing errors, or implementing interfaces.
Inputs: end_line (required), file_path (required), end_column (required), start_line (required), +2 more.
get_completionsB
Get completion suggestions at a specific location in a file. Use this tool to retrieve code completion options based on the current context, including variable names, function calls, object properties, and more. Helpful for code assistance and auto-completion at a particular location. Use this when determining which functions you have available in a given package, for example when changing libraries.
Inputs: line (required), column (required), file_path (required), language_id.
get_cross_repo_referencesA
Find all references to a library symbol across one or more consumer repositories. Adds each consumer_root as a workspace folder, waits for indexing, then calls get_references and partitions results by repo. Returns library_references (within the primary repo), consumer_references (map of root → locations), and warnings (roots that could not be indexed). Use before changing a shared library API to find all downstream callers.
Inputs: line (required), column (required), symbol_file (required), consumer_roots (required), +1 more.
get_diagnosticsA
Get diagnostic messages (errors, warnings) for files. Use this tool to identify problems in code files such as syntax errors, type mismatches, or other issues detected by the language server. When used without a file_path, returns diagnostics for all open files.
Inputs: file_path.
get_document_highlightsA
Find all occurrences of the symbol at a position within the same file via LSP (textDocument/documentHighlight). Returns ranges and kinds: 1=Text, 2=Read, 3=Write. File-scoped and instant — does not trigger a workspace-wide reference search. Use this to find all local usages of a variable, parameter, or field without the overhead of get_references.
Inputs: line (required), column (required), file_path (required), language_id.
get_document_symbolsA
Get all symbols defined in a document via LSP (functions, classes, variables, methods, etc.). Returns a hierarchical DocumentSymbol tree or flat SymbolInformation list depending on server support. Use this to get a structural overview of a file. Pass format: "outline" for compact markdown output (name [Kind] :line) optimized for LLM consumption — ~5x fewer tokens than JSON for the same structural information.
Inputs: file_path (required), format, language_id.
get_info_on_locationC
Get information on a specific location in a file via LSP hover. Use this tool to retrieve detailed type information, documentation, and other contextual details about symbols in your code. Particularly useful for understanding variable types, function signatures, and module documentation at a specific location in the code. Use this whenever you need to get a better idea on what a particular function is doing in that context.
Inputs: line (required), column (required), file_path (required), language_id, +1 more.
get_inlay_hintsA
Get inlay hints for a range within a document via LSP (textDocument/inlayHint). Inlay hints are inline annotations that IDEs display in source code — typically inferred type names (e.g. : string) and parameter name labels (e.g. count:). Useful in languages with type inference (TypeScript, Rust, Go) to see what the compiler knows without reading every type annotation. Returns an array of InlayHint objects, each with a position, label, and optional kind (1=Type, 2=Parameter). Returns an empty array if the language server does not support inlay hints.
Inputs: end_line (required), file_path (required), end_column (required), start_line (required), +2 more.
get_referencesA
Find all references to a symbol at a specific location in a file via LSP. Returns every location in the codebase where the symbol is used. Use this to determine if a symbol is dead (zero references), to understand call sites before refactoring, or to trace data flow. Results include file path and line/column for each reference.
Inputs: line (required), column (required), file_path (required), language_id, +2 more.
get_semantic_tokensA
Get semantic tokens for a range in a file. Returns each token's type (function, variable, keyword, parameter, type, etc.) and modifiers (readonly, static, deprecated, etc.) with 1-based line/character positions. Use this to understand the syntactic role of code elements — distinct from hover which gives documentation. Only available when the language server supports textDocument/semanticTokens.
Inputs: end_line (required), file_path (required), end_column (required), start_line (required), +2 more.
get_server_capabilitiesA
Return the language server's capability map and classify every agent-lsp tool as supported or unsupported based on what the server advertised during initialization. Use this to determine which tools will return results before calling them — saves round trips on servers that don't support certain LSP features (e.g. not all servers support type_hierarchy or inlay_hints). Requires start_lsp to have been called first.
get_signature_helpA
Get function signature help at a specific location in a file via LSP. Returns available overloads and highlights the active parameter. Use this when the cursor is inside a function call's argument list to understand what parameters the function expects.
Inputs: line (required), column (required), file_path (required), language_id.
get_symbol_documentationA
Fetch authoritative documentation for a named symbol from local toolchain sources (go doc, pydoc, cargo doc) without requiring an LSP hover response. Works on transitive dependencies not indexed by the language server. Returns the full doc text, extracted signature, and source tag. Falls back gracefully when the toolchain command fails or the language is unsupported.
Inputs: symbol (required), language_id (required), format, file_path.
get_symbol_sourceA
Return the source code of the innermost symbol (function, method, class, struct, etc.) whose range contains the given cursor position. Calls textDocument/documentSymbol, walks the symbol tree to find the smallest enclosing symbol, then slices the file at that symbol's range. Returns symbol_name, symbol_kind, start_line (1-based), end_line (1-based), and source text. Use line+character or position_pattern (@@-syntax) to specify the cursor. character defaults to 1.
Inputs: file_path (required), line, character, language_id, +1 more.
get_tests_for_fileA
Given a source file path, return the test files that exercise it. Static lookup — no test execution. Go: test.go in same directory. Python: test.py / *_test.py in same dir and tests/ sibling. TypeScript/JS: *.test.ts, *.spec.ts etc. Rust: returns source file itself (tests inline). Does not require start_lsp.
Inputs: file_path (required).
get_workspace_symbolsA
Search for symbols across the entire workspace via LSP. Returns all matching symbols with name, kind, and location. detail_level controls enrichment: omit or use "basic" for names/locations only; use "hover" to also return hover info (type signature + docs) for a paginated window of results. limit (default 3) and offset (default 0) control which symbols get enriched — use offset to step through results without re-running the search.
Inputs: limit, query, offset, detail_level.
go_to_declarationA
Jump to the declaration of a symbol at a specific location in a file via LSP. Completes the 'go to X' family alongside go_to_definition, go_to_type_definition, and go_to_implementation. Most useful for languages with separate declaration and definition (e.g., C/C++ header files). Returns the file path and position where the symbol is declared.
Inputs: line (required), column (required), file_path (required), language_id.
go_to_definitionC
Jump to the definition of a symbol at a specific location in a file via LSP. Returns the file path and position where the symbol is defined. Useful for navigating to type declarations, function implementations, or variable assignments across the codebase.
Inputs: line (required), column (required), file_path (required), language_id, +1 more.
go_to_implementationA
Find all implementations of an interface or abstract method at a specific location in a file via LSP. Returns the file paths and positions of all concrete implementations. Use this to navigate from an interface declaration or abstract method to the concrete classes that implement it.
Inputs: line (required), column (required), file_path (required), language_id.
go_to_symbolA
Navigate to a symbol definition by dot-notation name (e.g. "LSPClient.GetReferences", "http.Handler") without needing file_path or line/column. Uses workspace symbol search to locate the definition. Useful when you know the symbol name but not its location.
Inputs: symbol_path (required), language, workspace_root.
go_to_type_definitionA
Jump to the definition of the type of a symbol at a specific location in a file via LSP. Unlike go_to_definition (which goes to where the symbol itself is defined), this navigates to the type declaration. Useful for interface types, type aliases, and class definitions when working with instances or variables.
Inputs: line (required), column (required), file_path (required), language_id.
list_workspace_foldersA
List all currently active workspace folders. Use this to see which roots the language server is indexing.
open_documentA
Open a file in the LSP server for analysis. Use this tool before performing operations like getting diagnostics, hover information, or completions for a file. The file remains open for continued analysis until explicitly closed. The language_id parameter tells the server which language service to use (e.g., 'typescript', 'javascript', 'haskell'). The LSP server starts automatically on MCP launch.
Inputs: file_path (required), text, language_id.
prepare_renameA
Validate that a rename is possible at the given position before committing to rename_symbol. Returns the range that would be renamed and a placeholder name suggestion, or a message indicating rename is not supported at this position. Use this before rename_symbol to avoid attempting invalid renames. Returns null if the server does not support prepareRename.
Inputs: line (required), column (required), file_path (required), language_id.
remove_workspace_folderA
Remove a directory from the LSP workspace. The language server will stop indexing that folder.
Inputs: path (required).
rename_symbolA
Get a WorkspaceEdit for renaming a symbol across the entire workspace via LSP. Returns the edit object — NOT applied automatically. Use dry_run=true to preview what would change (returns workspace_edit + note). Use position_pattern with @@ marker for reliable position targeting instead of line/column. Inspect the returned WorkspaceEdit then call apply_edit to commit. Optional exclude_globs (array of glob patterns, e.g. ["vendor/", "/*_gen.go"]) skips matching files from the rename — useful for generated code, vendored files, and test fixtures.
Inputs: new_name (required), file_path (required), line, column, +4 more.
restart_lsp_serverA
Restart the LSP server process. Use this if the LSP server becomes unresponsive or after making significant changes to the project structure. Optionally provide a new root_dir to restart with a different workspace root.
Inputs: root_dir.
run_buildA
Compile the project at workspace_dir using the detected workspace language. Language-specific dispatch (no arbitrary shell execution): go build ./..., cargo build, tsc --noEmit, mypy . (Python typecheck proxy). Optional path param narrows scope. Returns: { success: bool, errors: [{file, line, column, message}], raw: string }. Does not require start_lsp.
Inputs: workspace_dir (required), path, language.
run_testsA
Run the test suite for the detected workspace language. Language-specific dispatch: go test -json ./..., cargo test --message-format=json, pytest --tb=json, npm test. Optional path param narrows scope. Test failure locations are LSP-normalized — paste directly into go_to_definition. Returns: { passed: bool, failures: [{file, line, test_name, message, location}], raw: string }. Does not require start_lsp.
Inputs: workspace_dir (required), path, language.
set_log_levelA
Set the server logging level. Use this tool to control the verbosity of logs generated by the LSP MCP server. Available levels from least to most verbose: emergency, alert, critical, error, warning, notice, info, debug. Increasing verbosity can help troubleshoot issues but may generate large amounts of output.
Inputs: level (required).
simulate_chainA
Apply a sequence of edits and evaluate after each step. Returns per-step diagnostics and identifies the safe-to-apply-through step (last step with net delta == 0). Use this to find the safest partial application of a multi-step change. All line/column positions in each edit are 1-indexed.
Inputs: edits (required), session_id (required), timeout_ms.
simulate_editA
Apply a range edit to a file within a simulation session. Changes are held in-memory only. The session captures baseline diagnostics on first edit to each file, then tracks versions for subsequent edits. Returns the new version number after the edit. All line/column positions are 1-indexed (matching editor line numbers).
Inputs: end_line (required), new_text (required), file_path (required), end_column (required), +3 more.
simulate_edit_atomicA
One-shot atomic operation: create session, apply edit, evaluate, and destroy. Returns evaluation result. Use for quick what-if checks without managing session lifecycle manually. Requires start_lsp to be called first. All line/column positions are 1-indexed. net_delta: 0 means the edit is safe to apply.
Inputs: end_line (required), new_text (required), file_path (required), end_column (required), +7 more.
start_lspA
Initialize or reinitialize the LSP server with a specific project root directory. Call this before using get_references, get_info_on_location, or get_diagnostics when working in a project different from the one the server was started with. root_dir should be the workspace root (directory containing go.mod, package.json, Cargo.toml, etc.). Optional language_id (e.g. "go", "typescript", "rust") selects a specific configured server in multi-server mode — use this when working in a mixed-language repo to ensure the correct server handles the workspace. If unsure which server is active, call get_server_capabilities first.
Inputs: root_dir (required), language_id.
type_hierarchyA
Show type hierarchy for a type at a position. Returns supertypes (parent classes/interfaces), subtypes (subclasses/implementations), or both depending on the direction parameter. Direction defaults to "both". Use this to understand class and interface inheritance relationships.
Inputs: line (required), column (required), file_path (required), direction, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 50 tools
Each tool targets a distinct LSP operation or workflow step. Navigation tools (go_to_definition, go_to_declaration, go_to_implementation, go_to_type_definition, go_to_symbol) are clearly differentiated by which aspect of the symbol they resolve. Simulation tools form a clear pipeline (create, edit, evaluate, commit/discard/destroy) with no overlap. All tools have unique purposes.
Tool names consistently follow a verb_noun pattern (e.g., open_document, get_references, rename_symbol). Some use 'get_' vs 'simulate_' but the pattern is uniform. Even compound names like simulate_edit_atomic follow the same convention. No mixed cases or unrelated verbs.
50 tools is high but justified by the comprehensive coverage of LSP features and additional utilities (simulation, build, test, cross-repo references). A few tools could potentially be merged (e.g., simulate_edit and simulate_edit_atomic) but overall the count reflects the server's ambition and the complexity of code analysis.
The tool set covers the full lifecycle of code interaction: document management, navigation, diagnostics, editing (with simulation), formatting, refactoring, testing, and building. It also includes workspace management, cross-repo references, and server introspection. No obvious gaps for an LSP-based code agent.
Maintenance
Related MCP Connectors
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
Hosted MCP server and Agent Skills for specs, engineering threads, and project memory.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Real-time chat for AI agents. Claude Code, Cursor, Cline and Codex join channels over MCP.
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP server that combines Read+Edit file operations into single tool calls. 80-95% fewer tool calls formulti-file refactoring across Claude, Cursor, Windsurf, and more.330 npm3MIT
- AlicenseNot gradedqualityBmaintenanceLocal-first code intelligence and safety layer for AI coding agents. MCP server exposes dependency graph, impact analysis, and AST-compressed repo context, backed by typed local memory, patch-scope safety gates, and git-independent transaction rollback.1MIT
- FlicenseNot gradedqualityCmaintenanceA local-first MCP server that gives AI coding agents durable project memory, dependency graphs, and impact analysis to answer team knowledge and cross-file change questions before editing.24 npm1-
- AlicenseCqualityBmaintenanceLocal-first MCP runtime for coding agents with bounded workspace access, content-preconditioned writes, AST search, LSP navigation and diagnostics, and Git status/diff. Designed to give coding agents useful repository access without treating unrestricted shell access as the default integration boundary.133MIT