Log inSubmit server
Agent Lsp logo

Agent Lsp

by blackwell-systems

Orchestrates language servers for agent-driven code navigation, impact analysis, diagnostics, and speculative edits.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Agent Lsp

Pick your client, then add it in one click or paste the config.

STDIOPython
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "blackwell-systems-agent-lsp": {
      "command": "uvx",
      "args": [
        "agent-lsp"
      ],
      "env": {
        "AGENT_LSP_OUTPUT_FORMAT": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

Install not yet sandbox-tested— the server itself is confirmed live (we called its tools/list endpoint). The stdio install command is a separate, ongoing check.

Overview

blackwell-systems/agent-lsp coordinates existing language servers such as gopls, rust-analyzer, and jdtls, then exposes their code intelligence through MCP tools. Persistent sessions keep workspace indexes warm across files, projects, and agent sessions, while batch operations combine multiple LSP requests into higher-level analyses. Speculative sessions let agents inspect diagnostic changes before committing edits to disk. Reach for it when an agent needs symbol-aware refactoring, cross-repository references, or repeatable code-analysis workflows across multiple languages.

Use cases

  • Analyze refactoring impact across a large codebase
  • Preview edits and compare diagnostic changes before writing files
  • Find library references across consumer repositories
  • Automate symbol-aware code navigation and verification workflows

Key features

  • Persistent language-server sessions and warm workspace indexes
  • Batch blast-radius analysis with test and non-test caller partitions
  • Speculative in-memory editing with diagnostic evaluation
  • Cross-repository symbol reference lookup
  • LSP-based diagnostics, formatting, completions, and semantic inspection
  • Compact GCF tool responses with a JSON fallback

Tools65

What Agent Lsp lets your agent do. Expand a tool for its parameters.

Verified live~12.9k tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked Today

Recent health check succeeded.

21/21 checks healthy over the last 78d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 8d ago via OSV.dev · agent-lsp (PyPI)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars165Stargazers on the source repository.
Last commit1d agoMost recent push to the default branch.
Tools exposed65Callable tools this server registers over MCP.
Directory activity13 viewsConfig copies, upvotes, and views on AllMCPs.

How Agent Lsp works

What blackwell-systems/agent-lsp MCP server does

blackwell-systems/agent-lsp turns existing language servers into MCP-accessible workflows for AI agents. It is an orchestration layer rather than a language server itself: tools such as gopls, rust-analyzer, jdtls, and other configured servers provide the underlying code intelligence, while agent-lsp manages their sessions and presents higher-level operations.

The server is designed for semantic code work rather than plain text search. Agents can locate symbols, inspect callers and references, read diagnostics, request completions, obtain formatting edits, and examine semantic information from source files. Workspace-aware operations also support multiple repositories, including references from a shared library into consumer projects.

How it works

A persistent runtime maintains language-server sessions and indexed workspaces across requests. Start the LSP runtime before using operations that depend on it, then add workspace folders when analysis must span repositories. detect_lsp_servers can scan a project, find language-server binaries on PATH, and produce a suggested configuration for the server.

For potentially risky changes, create a simulation session and perform edits in memory. Diagnostic baselines are captured as files are first changed; evaluate_session compares the resulting diagnostics with those baselines and reports errors introduced, errors resolved, the net change, and a confidence value. The session can then be committed to disk, discarded, or destroyed. Direct edits should be checked with preview_edit before applying them when that workflow is available.

The server also supports workflow guardrails through skills. Activating a skill enforces permitted phases for tool calls, helping keep operations such as impact analysis, editing, and verification in order.

Setup and configuration

The project provides a single-binary installation path:

Terminal
curl -fsSL https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.sh | sh && agent-lsp init

After installation, initialize the server for the workspace and ensure the language-server binaries required by the project are available. detect_lsp_servers reports detected languages and installed servers, which can help build or verify the configuration. The server can route different file types to different language servers within one session.

Tool responses use GCF, a compact structured format, by default. Set AGENT_LSP_OUTPUT_FORMAT=json to switch the output format back to JSON.

Tools and capabilities

  • Analyze exported symbols and their callers with blast_radius, including test and non-test partitions and optional transitive callers.
  • Search symbols, references, callers, completions, document highlights, inlay hints, semantic tokens, and language-server diagnostics.
  • Inspect or request edits from language servers with formatting tools, then apply workspace edits or text-match replacements.
  • Trace dependencies across repositories with add_workspace_folder and get_cross_repo_references.
  • Create, evaluate, commit, discard, and destroy speculative editing sessions.
  • Export a compressed symbol-reference cache for team sharing after the LSP runtime has started.

Limitations and notes

agent-lsp depends on the language servers that provide the underlying analysis, so the relevant binaries must be installed and configured for the project. Language features also depend on what each language server supports; for example, semantic tokens and inlay hints can return no results when the underlying server lacks those capabilities.

Formatting returns edits for inspection rather than changing files automatically. Applying edits and committing simulation results are separate actions. Files changed directly on disk should be reported with did_change_watched_files so the language server can refresh its state. Close documents that are no longer needed to reduce resource use during long-running or large-workspace sessions.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Agent Lsp

blackwell-systems/agent-lsp is an MCP server that orchestrates existing language servers such as gopls, rust-analyzer, and jdtls for AI-agent code intelligence. Its main tools cover symbol search, references and callers, diagnostics, blast-radius analysis, formatting, cross-repository lookup, and speculative edit sessions that can be evaluated before changes reach disk.

Install it with the project’s shell command, then initialize it with `agent-lsp init`. The command downloads the single binary and runs initialization: `curl -fsSL https://raw.githubusercontent.com/blackwell-systems/agent-lsp/main/install.sh | sh && agent-lsp init`. Required language-server binaries must also be installed and configured.

Use `detect_lsp_servers` to scan the workspace, check for language-server binaries on `PATH`, and generate a suggested configuration. The server routes file types to configured language servers, and `add_workspace_folder` adds additional repositories after the LSP runtime starts.

Yes, Cursor is named as a client used with blackwell-systems/agent-lsp. Configure the MCP server in Cursor and provide the project’s language-server setup so its tools can access indexed workspaces, references, diagnostics, and editing workflows.

Related MCP servers

All in Databases All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewAgent Lsp AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/blackwell-systems-agent-lsp?style=directory)](https://allmcps.com/mcp/blackwell-systems-agent-lsp)
HTML Embed
<a href="https://allmcps.com/mcp/blackwell-systems-agent-lsp"><img src="https://allmcps.com/api/badge/blackwell-systems-agent-lsp?style=directory" alt="Agent Lsp on AllMCPs" /></a>