Server profile

MCP Language Server

Expose an installed language server to MCP assistants for semantic code navigation and edits. It provides definitions, references, diagnostics, hover information, symbol renaming, and line-based file changes.

Server facts

MCP Language Server

Project

Author
isaacphi
License
BSD-3-Clause

Tech

Runtime / language
goGo
Transports
stdio
Remote available
No
Authentication
Not specified

Activity

GitHub stars
1,610
Last commit
Data as of

Tags

  • Code Navigation
  • Diagnostics
  • Go
  • Language Server Protocol
  • Refactoring

Overview

MCP Language Server is a bridge from an MCP-enabled assistant to a separate Language Server Protocol implementation. It does not implement language intelligence itself; instead, it starts a chosen language server for a workspace and exposes semantic operations to the assistant. Developers can use it to locate definitions, trace references, inspect errors, or read type information without relying entirely on text search. A line-based edit tool complements the language-aware navigation and rename operations.

The README supplies configurations for Go through gopls, Rust through rust-analyzer, Python through pyright, TypeScript through typescript-language-server, and C or C++ through clangd. Other servers may work, but those listed are the ones the author reports testing. The connected language server must use stdio. Arguments following the separator are forwarded to that server, and environment variables are inherited as well. For clangd, the documentation highlights the importance of a generated compilation database.

Setup requires Go, installation of the bridge, and a separately installed language server. The client configuration then specifies both the workspace directory and the language-server executable. Some clients need explicit executable paths or language-specific environment settings; the Go example discusses this in detail. Debug logging can expose the protocol exchange on stderr for troubleshooting. The project is described as beta software, so integration behavior should be checked against the selected server and workspace before relying on it for broader edits.

Install & configure

Requirements

  • Go
  • Bridge installed with go install github.com/isaacphi/mcp-language-server@latest
  • rust-analyzer installed for this example
  • An MCP client and a local workspace
Documented launch / install command
mcp-language-server --workspace /Users/you/dev/yourproject/ --lsp rust-analyzer

This is the README's Rust example. Replace the workspace path and choose the appropriate installed language server. Other documented configurations cover gopls, pyright, TypeScript, and clangd.

Config file · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Use Settings → Developer → Edit Config when available. Do not assume a Linux configuration path; check the client documentation for your platform. Remote servers use the app’s connector flow when supported, not the local stdio file shown here. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Desktop configuration
{
  "mcpServers": {
    "mcp-language-server": {
      "command": "mcp-language-server",
      "args": [
        "--workspace",
        "/Users/you/dev/yourproject/",
        "--lsp",
        "rust-analyzer"
      ],
      "env": {}
    }
  }
}

Read the Claude Desktop setup guide

Config file · Project: .cursor/mcp.json

User: ~/.cursor/mcp.json

The project path is relative to the workspace root. The tilde denotes your user home directory. Use Cursor’s MCP settings to confirm which configuration and scope your installed version is reading. Merge this example with existing settings; do not overwrite unrelated servers.

Cursor configuration
{
  "mcpServers": {
    "mcp-language-server": {
      "command": "mcp-language-server",
      "args": [
        "--workspace",
        "/Users/you/dev/yourproject/",
        "--lsp",
        "rust-analyzer"
      ],
      "env": {}
    }
  }
}

Read the Cursor setup guide

Config file · Workspace: .vscode/mcp.json

For user scope, use the “MCP: Open User Configuration” command if available. Do not guess a user configuration path across operating systems, profiles, containers, or remote workspaces; check the client documentation. Merge this example with existing settings; do not overwrite unrelated servers.

VS Code configuration
{
  "servers": {
    "mcp-language-server": {
      "type": "stdio",
      "command": "mcp-language-server",
      "args": [
        "--workspace",
        "/Users/you/dev/yourproject/",
        "--lsp",
        "rust-analyzer"
      ],
      "env": {}
    }
  }
}

Read the VS Code setup guide

Config file · macOS/Linux: ~/.codeium/windsurf/mcp_config.json

Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json

Open the MCP configuration through Windsurf’s settings when possible to confirm the active file. Paths can differ in managed or future releases; check the client documentation if this location is not present. Merge this example with existing settings; do not overwrite unrelated servers.

Windsurf configuration
{
  "mcpServers": {
    "mcp-language-server": {
      "command": "mcp-language-server",
      "args": [
        "--workspace",
        "/Users/you/dev/yourproject/",
        "--lsp",
        "rust-analyzer"
      ],
      "env": {}
    }
  }
}

Read the Windsurf setup guide

Config file · Project scope: .mcp.json at the repository root

The project file uses mcpServers. For user scope, use claude mcp add --scope user rather than assuming .mcp.json in your home directory is the user configuration. Check the client documentation for managed settings and storage details. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Code configuration
{
  "mcpServers": {
    "mcp-language-server": {
      "type": "stdio",
      "command": "mcp-language-server",
      "args": [
        "--workspace",
        "/Users/you/dev/yourproject/",
        "--lsp",
        "rust-analyzer"
      ],
      "env": {}
    }
  }
}

Read the Claude Code setup guide

Examples are translated from the published configuration. Supply your own credentials and verify requirements in the upstream README. Remote connectors are shown only where a supported configuration format is known.

Tools

Source: repository README. Tool descriptions are a documented snapshot, not a live capability check.

ToolWhat it does
definitionResolve a symbol to its source definition.
referencesFind places in the workspace that use a symbol.
diagnosticsRead warnings and errors reported for a file.
hoverRetrieve documentation and type details at a code location.
rename_symbolApply a language-aware symbol rename across the project.
edit_fileApply multiple file changes using line positions.

Names, permissions, and defaults can change. Check the current upstream documentation before granting access.

Use cases

  • Locate a function definition and its callers through semantic queries.
  • Inspect file diagnostics while an assistant changes code.
  • Rename a symbol consistently across a project.
  • Give a coding client language intelligence without embedding an IDE.

Strengths

  • Uses established language servers for semantic operations.
  • Documents configurations for several major languages.
  • Includes symbol renaming and batched line-based edits.

Limitations

  • Requires a separately installed language server.
  • The underlying server must communicate through stdio.
  • The README labels the project beta software.

Frequently asked questions

No. It exposes an existing language server to an MCP assistant.

The README includes gopls, rust-analyzer, pyright, typescript-language-server, and clangd configurations.

Arguments after -- are forwarded to the underlying language server.

Set LOG_LEVEL to DEBUG to enable verbose stderr logs, including language-server messages.

Independent listing, not an affiliation or security review. Grant the least access needed and verify the upstream instructions before running code.

Related MCP servers

MCP for Unity

Games & 3D

MCP for Unity links AI assistants to the Unity Editor for scene work, asset management, script editing, testing, and builds. It targets game developers who want to direct editor workflows through natural language.

MCP Advisor

Developer Tools

MCP Advisor helps assistants discover MCP servers from natural-language requests and obtain installation guidance. It combines registry providers with offline search and offers optional local Meilisearch integration.

Serena

Developer Tools

Serena gives coding agents symbol-aware retrieval, editing, refactoring, and debugging capabilities through MCP. It uses language servers or a JetBrains plugin to bring IDE-style code understanding to existing AI clients.

Context7

Developer Tools

Context7 retrieves current library documentation and code examples for AI coding assistants. It supports MCP tools or a CLI-and-skills workflow, with library IDs and version-aware requests helping narrow the documentation context.

FastAPI-MCP

Developer Tools

FastAPI-MCP exposes existing FastAPI endpoints as MCP tools while retaining schemas, endpoint documentation, and dependency-based authentication. It is a native extension for developers adding agent access to a FastAPI service.

GitMCP

Developer Tools

GitMCP turns public GitHub repositories and GitHub Pages projects into documentation sources for AI assistants. It offers repository-specific endpoints or a dynamic server for retrieving docs, searching code, and following referenced content.

XcodeBuildMCP

Developer Tools

XcodeBuildMCP provides an MCP server and CLI for AI agents working on iOS and macOS projects. One package supports direct terminal tools, simulator builds, and stateful operations such as debugging and log capture.

DevDocs by CyberAGI

Developer Tools

Crawl technical documentation into organized Markdown, JSON, and MCP-accessible content for development assistants. The public DevDocs repository is marked as not publicly maintained.