LSP MCP Server

Integra-se ao Language Server Protocol (LSP) para fornecer recursos como conclusão de código, diagnósticos e informações ao passar o mouse.

GitHub
123
Experimente este MCPPatrocinado

Documentação

LSP MCP Server

Um servidor MCP (Model Context Protocol) para interagir com a interface LSP (Language Server Protocol). Este servidor atua como uma ponte que permite que LLMs consultem os provedores de Hover e Completion do LSP.

Visão Geral

O MCP Server funciona da seguinte forma:

  1. Inicia um cliente LSP que se conecta a um servidor LSP
  2. Expõe ferramentas MCP que enviam solicitações ao servidor LSP
  3. Retorna os resultados em um formato que os LLMs possam entender e usar

Isso permite que os LLMs utilizem LSPs para sugestões de código mais precisas.

Configuração:

{
  "mcpServers": {
    "lsp-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "tritlo/lsp-mcp",
        "<language-id>",
        "<path-to-lsp>",
        "<lsp-args>"
      ]
    }
  }
}

Recursos

Ferramentas MCP

  • get_info_on_location: Obter informações de hover em um local específico de um arquivo
  • get_completions: Obter sugestões de conclusão em um local específico de um arquivo
  • get_code_actions: Obter ações de código para um intervalo específico em um arquivo
  • open_document: Abrir um arquivo no servidor LSP para análise
  • close_document: Fechar um arquivo no servidor LSP
  • get_diagnostics: Obter mensagens de diagnóstico (erros, avisos) para arquivos abertos
  • start_lsp: Iniciar o servidor LSP com um diretório raiz especificado
  • restart_lsp_server: Reiniciar o servidor LSP sem reiniciar o servidor MCP
  • set_log_level: Alterar o nível de verbosidade de registro do servidor em tempo de execução

Recursos MCP

  • Recursos lsp-diagnostics:// para acessar mensagens de diagnóstico com atualizações em tempo real via assinaturas
  • Recursos lsp-hover:// para recuperar informações de hover em locais específicos de arquivos
  • Recursos lsp-completions:// para obter sugestões de conclusão de código em posições específicas

Recursos Adicionais

  • Sistema de registro abrangente com múltiplos níveis de severidade
  • Saída de console colorida para melhor legibilidade
  • Nível de registro configurável em tempo de execução
  • Tratamento e relatório de erros detalhados
  • Interface de linha de comando simples

Pré-requisitos

  • Node.js (v16 ou posterior)
  • npm

Para o servidor de demonstração:

  • GHC (8.10 ou posterior)
  • Cabal (3.0 ou posterior)

Instalação

Compilando o MCP Server

  1. Clone este repositório:

    git clone https://github.com/your-username/lsp-mcp.git
cd lsp-mcp

  2. Instale as dependências:

    npm install

  3. Compile o servidor MCP:

    npm run build

Testes

O projeto inclui testes de integração para o suporte LSP do TypeScript. Esses testes verificam se o servidor LSP-MCP lida corretamente com operações LSP, como informações de hover, conclusões, diagnósticos e ações de código.

Executando Testes

Para executar os testes LSP do TypeScript:

npm test

ou especificamente:

npm run test:typescript

Cobertura de Testes

Os testes verificam as seguintes funcionalidades:

  • Inicializar o LSP do TypeScript com um projeto simulado
  • Abrir arquivos TypeScript para análise
  • Obter informações de hover para funções e tipos
  • Obter sugestões de conclusão de código
  • Obter mensagens de erro de diagnóstico
  • Obter ações de código para erros

O projeto de teste está localizado em test/ts-project/ e contém arquivos TypeScript com erros intencionais para testar o feedback de diagnóstico.

Uso

Execute o servidor MCP fornecendo o caminho para o executável LSP e quaisquer argumentos a serem passados ao servidor LSP:

npx tritlo/lsp-mcp <language> /path/to/lsp [lsp-args...]

Por exemplo:

npx tritlo/lsp-mcp haskell /usr/bin/haskell-language-server-wrapper lsp

Importante: Iniciando o Servidor LSP

A partir da versão 0.2.0 e posteriores, você deve iniciar explicitamente o servidor LSP chamando a ferramenta start_lsp antes de usar qualquer funcionalidade LSP. Isso garante a inicialização adequada com o diretório raiz correto, o que é especialmente importante ao usar ferramentas como npx:

{
  "tool": "start_lsp",
  "arguments": {
    "root_dir": "/path/to/your/project"
  }
}

Registro

O servidor inclui um sistema de registro abrangente com 8 níveis de severidade:

  • debug: Informações detalhadas para fins de depuração
  • info: Mensagens informativas gerais sobre a operação do sistema
  • notice: Eventos operacionais significativos
  • warning: Problemas potenciais que podem precisar de atenção
  • error: Condições de erro que afetam a operação, mas não interrompem o sistema
  • critical: Condições críticas que exigem atenção imediata
  • alert: O sistema está em um estado instável
  • emergency: O sistema está inutilizável

Por padrão, os registros são enviados para:

  1. Saída do console com codificação de cores para melhor legibilidade
  2. Notificações MCP para o cliente (via método notifications/message)

Visualizando Registros de Depuração

Para depuração detalhada, você pode:

  1. Usar o sinalizador claude --mcp-debug ao executar o Claude para ver todo o tráfego MCP entre o Claude e o servidor:

    claude --mcp-debug

  2. Alterar o nível de registro em tempo de execução usando a ferramenta set_log_level:

    {
  "tool": "set_log_level",
  "arguments": {
    "level": "debug"
  }
}

O nível de registro padrão é info, que mostra detalhes operacionais moderados enquanto filtra mensagens de depuração verbosas.

API

O servidor fornece as seguintes ferramentas MCP:

get_info_on_location

Obtém informações de hover em um local específico de um arquivo.

Parâmetros:

  • file_path: Caminho para o arquivo
  • language_id: A linguagem de programação em que o arquivo está escrito (por exemplo, "haskell")
  • line: Número da linha
  • column: Posição da coluna

Exemplo:

{
  "tool": "get_info_on_location",
  "arguments": {
    "file_path": "/path/to/your/file",
    "language_id": "haskell",
    "line": 3,
    "column": 5
  }
}

get_completions

Obtém sugestões de conclusão em um local específico de um arquivo.

Parâmetros:

  • file_path: Caminho para o arquivo
  • language_id: A linguagem de programação em que o arquivo está escrito (por exemplo, "haskell")
  • line: Número da linha
  • column: Posição da coluna

Exemplo:

{
  "tool": "get_completions",
  "arguments": {
    "file_path": "/path/to/your/file",
    "language_id": "haskell",
    "line": 3,
    "column": 10
  }
}

get_code_actions

Obtém ações de código para um intervalo específico em um arquivo.

Parâmetros:

  • file_path: Caminho para o arquivo
  • language_id: A linguagem de programação em que o arquivo está escrito (por exemplo, "haskell")
  • start_line: Número da linha inicial
  • start_column: Posição da coluna inicial
  • end_line: Número da linha final
  • end_column: Posição da coluna final

Exemplo:

{
  "tool": "get_code_actions",
  "arguments": {
    "file_path": "/path/to/your/file",
    "language_id": "haskell",
    "start_line": 3,
    "start_column": 5,
    "end_line": 3,
    "end_column": 10
  }
}

start_lsp

Inicia o servidor LSP com um diretório raiz especificado. Isso deve ser chamado antes de usar qualquer outra ferramenta relacionada ao LSP.

Parâmetros:

  • root_dir: O diretório raiz para o servidor LSP (caminho absoluto recomendado)

Exemplo:

{
  "tool": "start_lsp",
  "arguments": {
    "root_dir": "/path/to/your/project"
  }
}

restart_lsp_server

Reinicia o processo do servidor LSP sem reiniciar o servidor MCP. Isso é útil para se recuperar de problemas do servidor LSP ou para aplicar alterações na configuração do servidor LSP.

Parâmetros:

  • root_dir: (Opcional) O diretório raiz para o servidor LSP. Se fornecido, o servidor será inicializado com este diretório após a reinicialização.

Exemplo sem root_dir (usa o diretório raiz definido anteriormente):

{
  "tool": "restart_lsp_server",
  "arguments": {}
}

Exemplo com root_dir:

{
  "tool": "restart_lsp_server",
  "arguments": {
    "root_dir": "/path/to/your/project"
  }
}

open_document

Abre um arquivo no servidor LSP para análise. Isso deve ser chamado antes de acessar diagnósticos ou realizar outras operações no arquivo.

Parâmetros:

  • file_path: Caminho para o arquivo a ser aberto
  • language_id: A linguagem de programação em que o arquivo está escrito (por exemplo, "haskell")

Exemplo:

{
  "tool": "open_document",
  "arguments": {
    "file_path": "/path/to/your/file",
    "language_id": "haskell"
  }
}

close_document

Fecha um arquivo no servidor LSP quando você terminar de trabalhar com ele. Isso ajuda a gerenciar recursos e limpeza.

Parâmetros:

  • file_path: Caminho para o arquivo a ser fechado

Exemplo:

{
  "tool": "close_document",
  "arguments": {
    "file_path": "/path/to/your/file"
  }
}

get_diagnostics

Obtém mensagens de diagnóstico (erros, avisos) para um ou todos os arquivos abertos.

Parâmetros:

  • file_path: (Opcional) Caminho para o arquivo para obter diagnósticos. Se não fornecido, retorna diagnósticos para todos os arquivos abertos.

Exemplo para um arquivo específico:

{
  "tool": "get_diagnostics",
  "arguments": {
    "file_path": "/path/to/your/file"
  }
}

Exemplo para todos os arquivos abertos:

{
  "tool": "get_diagnostics",
  "arguments": {}
}

set_log_level

Define o nível de registro do servidor para controlar a verbosidade das mensagens de registro.

Parâmetros:

  • level: O nível de registro a ser definido. Um de: debug, info, notice, warning, error, critical, alert, emergency.

Exemplo:

{
  "tool": "set_log_level",
  "arguments": {
    "level": "debug"
  }
}

Recursos MCP

Além das ferramentas, o servidor fornece recursos para acessar recursos LSP, incluindo diagnósticos, informações de hover e conclusões de código:

Recursos de Diagnóstico

O servidor expõe informações de diagnóstico por meio do esquema de recurso lsp-diagnostics://. Esses recursos podem ser assinados para atualizações em tempo real quando os diagnósticos mudam.

URIs de recurso:

  • lsp-diagnostics:// - Diagnósticos para todos os arquivos abertos
  • lsp-diagnostics:///path/to/file - Diagnósticos para um arquivo específico

Importante: Os arquivos devem ser abertos usando a ferramenta open_document antes que os diagnósticos possam ser acessados.

Recursos de Informações de Hover

O servidor expõe informações de hover por meio do esquema de recurso lsp-hover://. Isso permite obter informações sobre elementos de código em posições específicas em arquivos.

Formato do URI do recurso:

lsp-hover:///path/to/file?line={line}&column={column}&language_id={language_id}

Parâmetros:

  • line: Número da linha (baseado em 1)
  • column: Posição da coluna (baseada em 1)
  • language_id: A linguagem de programação (por exemplo, "haskell")

Exemplo:

lsp-hover:///home/user/project/src/Main.hs?line=42&column=10&language_id=haskell

Recursos de Conclusão de Código

O servidor expõe sugestões de conclusão de código por meio do esquema de recurso lsp-completions://. Isso permite obter candidatos de conclusão em posições específicas em arquivos.

Formato do URI do recurso:

lsp-completions:///path/to/file?line={line}&column={column}&language_id={language_id}

Parâmetros:

  • line: Número da linha (baseado em 1)
  • column: Posição da coluna (baseada em 1)
  • language_id: A linguagem de programação (por exemplo, "haskell")

Exemplo:

lsp-completions:///home/user/project/src/Main.hs?line=42&column=10&language_id=haskell

Listando Recursos Disponíveis

Para descobrir recursos disponíveis, use o endpoint MCP resources/list. A resposta incluirá todos os recursos disponíveis para arquivos atualmente abertos, incluindo:

  • Recursos de diagnóstico para todos os arquivos abertos
  • Modelos de informações de hover para todos os arquivos abertos
  • Modelos de conclusão de código para todos os arquivos abertos

Assinando Atualizações de Recursos

Os recursos de diagnóstico suportam assinaturas para receber atualizações em tempo real quando os diagnósticos mudam (por exemplo, quando os arquivos são modificados e novos erros ou avisos aparecem). Assine os recursos de diagnóstico usando o endpoint MCP resources/subscribe.

Nota: Os recursos de hover e conclusão não suportam assinaturas, pois representam consultas pontuais.

Trabalhando com Recursos vs. Ferramentas

Você pode escolher entre duas abordagens para acessar os recursos LSP:

  1. Abordagem baseada em ferramentas: Use as ferramentas get_diagnostics, get_info_on_location e get_completions para uma maneira simples e direta de buscar informações.
  2. Abordagem baseada em recursos: Use os recursos lsp-diagnostics://, lsp-hover:// e lsp-completions:// para uma abordagem mais RESTful.

Ambas as abordagens fornecem os mesmos dados no mesmo formato e impõem o mesmo requisito de que os arquivos devem ser abertos primeiro.

Solução de Problemas

  • Se o servidor falhar ao iniciar, certifique-se de que o caminho para o executável LSP esteja correto
  • Verifique o arquivo de registro (se configurado) para mensagens de erro detalhadas

Licença

Licença MIT

Extensões

O servidor LSP-MCP suporta extensões específicas de linguagem que aprimoram suas capacidades para diferentes linguagens de programação. As extensões podem fornecer:

  • Ferramentas e funcionalidades personalizadas específicas do LSP
  • Manipuladores e modelos de recursos específicos de linguagem
  • Prompts especializados para tarefas relacionadas à linguagem
  • Manipuladores de assinatura personalizados para dados em tempo real

Extensões Disponíveis

Atualmente, as seguintes extensões estão disponíveis:

  • Haskell: Fornece prompts especializados para desenvolvimento Haskell, incluindo orientação para exploração de buracos tipados

Usando Extensões

As extensões são carregadas automaticamente quando você especifica um ID de idioma ao iniciar o servidor:

npx tritlo/lsp-mcp haskell /path/to/haskell-language-server-wrapper lsp

Namespacing de Extensões

Todos os recursos fornecidos por extensões são namespaced com o ID do idioma. Por exemplo, o prompt de buraco tipado da extensão Haskell está disponível como haskell.typed-hole-use.

Criando Novas Extensões

Para criar uma nova extensão:

  1. Crie um novo arquivo TypeScript em src/extensions/ nomeado após sua linguagem (por exemplo, typescript.ts)

  2. Implemente a interface Extension com qualquer uma dessas funções opcionais:

    • getToolHandlers(): Fornecer implementações de ferramentas personalizadas
    • getToolDefinitions(): Definir ferramentas personalizadas na API MCP
    • getResourceHandlers(): Implementar manipuladores de recursos personalizados
    • getSubscriptionHandlers(): Implementar manipuladores de assinatura personalizados
    • getUnsubscriptionHandlers(): Implementar manipuladores de cancelamento de assinatura personalizados
    • getResourceTemplates(): Definir modelos de recursos personalizados
    • getPromptDefinitions(): Definir prompts personalizados para tarefas de linguagem
    • getPromptHandlers(): Implementar manipuladores de prompts personalizados

  3. Exporte suas funções de implementação

O sistema de extensões carregará automaticamente sua extensão quando o ID de idioma correspondente for especificado.

Agradecimentos

  • Equipe HLS pela implementação do Language Server Protocol
  • Anthropic pela especificação do Model Context Protocol