MCP LSP Go

Un servidor MCP que conecta asistentes de IA al Protocolo de Servidor de Lenguaje (LSP) de Go para análisis de código avanzado.

GitHub

102

Prueba este MCPPatrocinado

Documentación

mcp-gopls – Servidor MCP para Go (gopls)

Un servidor de Protocolo de Contexto de Modelo (MCP) que permite a los asistentes de IA utilizar el LSP de Go (gopls) para navegación, diagnósticos, pruebas, cobertura y más.

TL;DR: Si usas Claude / Cursor / Copilot con Go, mcp-gopls le da a la IA todos los poderes del LSP: ir a definición, referencias, hover, autocompletado, go test, cobertura, go mod tidy, govulncheck, etc.

Demo Animation

Resumen

Este servidor MCP ayuda a los asistentes de IA a:

Usar LSP para analizar espacios de trabajo de Go
Navegar a definiciones, referencias y símbolos del espacio de trabajo
Formatear, renombrar e inspeccionar acciones de código sin salir de MCP
Ejecutar pruebas de Go, cobertura, go mod tidy, govulncheck y comandos de grafo de módulos con resultados estructurados
Leer recursos del espacio de trabajo (resumen + go.mod) y consumir prompts seleccionados

Estado: En desarrollo activo – utilizado en proyectos reales.
Probado con Go 1.25.x y gopls@latest.

Arquitectura

Este proyecto utiliza la biblioteca mark3labs/mcp-go para implementar el Protocolo de Contexto de Modelo. La integración MCP permite una comunicación fluida entre asistentes de IA y herramientas de Go.

El servidor se comunica con gopls, el servidor de lenguaje oficial para Go, mediante el Protocolo de Servidor de Lenguaje (LSP).

Características

Runtime configurable: --workspace, --gopls-path, --log-level, --rpc-timeout y --shutdown-timeout flags + variables de entorno (MCP_GOPLS_*)
Registro estructurado: Registro de texto/JSON con slog y salida opcional a archivo
Superficie LSP extendida: navegación, diagnósticos, formateo, renombrado, acciones de código, hover, autocompletado, símbolos del espacio de trabajo
Ayudantes de pruebas y herramientas: análisis de cobertura, go test, go mod tidy, govulncheck, go mod graph
Extras de MCP: recursos (resource://workspace/overview, resource://workspace/go.mod) y prompts (summarize_diagnostics, refactor_plan)
Transmisión de progreso: los comandos de larga duración emiten eventos notifications/progress para que los clientes puedan mostrar actualizaciones de estado

Comparación de características: `mcp-gopls` vs MCP integrado de `gopls`

A partir de gopls v0.20.0, el servidor MCP integrado expone estas herramientas: go_context, go_diagnostics, go_file_context, go_file_diagnostics, go_file_metadata, go_package_api, go_references, go_rename_symbol, go_search, go_symbol_references, go_workspace, go_vulncheck.

Característica / capacidad	`mcp-gopls` (este proyecto)	MCP integrado de `gopls`
Ir a definición	Sí (herramienta `go_to_definition`)	Sin herramienta MCP dedicada (no está en la lista de herramientas)
Buscar referencias	Sí (`find_references`)	Sí (`go_references`, `go_symbol_references`)
Diagnósticos (archivo / espacio de trabajo)	Sí (`check_diagnostics`)	Sí (`go_diagnostics`, `go_file_diagnostics`)
Información hover	Sí (`get_hover_info`)	Sin herramienta MCP dedicada (no está en la lista de herramientas)
Autocompletado	Sí (`get_completion`)	Sin herramienta MCP dedicada (no está en la lista de herramientas)
Formateo	Sí (`format_document`)	Sin herramienta MCP dedicada (no está en la lista de herramientas)
Renombrar símbolo	Sí (`rename_symbol`)	Sí (`go_rename_symbol`)
Acciones de código	Sí (`list_code_actions`)	Sin herramienta MCP dedicada (no está en la lista de herramientas)
Búsqueda de símbolos del espacio de trabajo	Sí (`search_workspace_symbols`)	Sí (`go_search`)
Herramientas de API/contexto de paquete / espacio de trabajo	Sin herramienta MCP dedicada	Sí (`go_package_api`, `go_file_context`, `go_file_metadata`, `go_workspace`, `go_context`)
Ejecutar `go test`	Sí (`run_go_test`)	Sin herramienta MCP para ejecutar pruebas
Análisis de cobertura	Sí (`analyze_coverage`)	Sin herramienta MCP para cobertura
`go mod tidy`	Sí (`run_go_mod_tidy`)	Sin herramienta MCP para `go mod tidy`
`govulncheck`	Sí (`run_govulncheck`)	Sí (`go_vulncheck`)
Grafo de módulos (`go mod graph`)	Sí (`module_graph`)	Sin herramienta MCP para grafo de módulos
Recursos MCP adicionales	Sí (`resource://workspace/overview`, `resource://workspace/go.mod`)	No documentados como recursos MCP
Prompts MCP personalizados	Sí (`summarize_diagnostics`, `refactor_plan`)	No expuestos como prompts MCP (solo instrucciones de modelo)
Instrucciones de modelo incluidas con el servidor	Sin mecanismo especial (documentado en README/docs)	Sí: `gopls mcp -instructions` imprime flujos de trabajo de uso

Si quieres edición completa tipo LSP + herramientas desde MCP (definición, hover, autocompletado, formato, renombrado, acciones de código, go test, cobertura, go mod tidy, grafo de módulos), mcp-gopls es estrictamente más rico.

Si principalmente quieres herramientas de solo lectura/introspectivas (diagnósticos, búsqueda de símbolos, referencias, API de paquetes, contexto de espacio de trabajo/archivo, vulncheck) sin binario adicional, el MCP integrado de gopls es suficiente.

Nota: El servidor MCP integrado de gopls sigue marcado como experimental y su conjunto de herramientas puede cambiar con el tiempo. Esta comparación es precisa a partir de gopls v0.20.x.

Estructura del Proyecto

.
├── cmd
│   └── mcp-gopls        # Application entry point
├── pkg
│   ├── lsp             # LSP client to communicate with gopls
│   │   ├── client      # LSP client implementation
│   │   └── protocol    # LSP protocol types and features
│   ├── server          # MCP server
│   └── tools           # MCP tools exposing LSP features

Instalación

go install github.com/hloiseau/mcp-gopls/v2/cmd/mcp-gopls@latest

Inicio Rápido

Instala el servidor:

go install github.com/hloiseau/mcp-gopls/v2/cmd/mcp-gopls@latest

Verifica que esté en tu $PATH:

mcp-gopls --help

Configura tu cliente de IA (consulta los ejemplos a continuación para Cursor, Claude Desktop o GitHub Copilot).

Docker / MCP Gateway

Si prefieres ejecutar mcp-gopls en un contenedor (para Docker MCP Gateway u otras configuraciones containerizadas), usa la imagen oficial.

Ejecución con Docker

docker run --rm -i \
  -v /absolute/path/to/your/go/project:/workspace \
  ghcr.io/hloiseau/mcp-gopls:latest \
  --workspace /workspace

docker-mcp.yaml

Copia docs/docker-mcp.yaml, actualiza la ruta del bind mount y luego ejecuta desde ese directorio:

docker mcp gateway run

Metadatos del catálogo de herramientas

Si tu herramienta de catálogo MCP requiere un toolsUrl, usa docs/tools.json como lista estática de herramientas.

Configuración Detallada del Cliente

Nota: Todos los clientes apuntan al mismo comando:
mcp-gopls --workspace /absolute/path/to/your/go/project
El formato de configuración difiere ligeramente por cliente, pero el binario y los argumentos permanecen idénticos.

1. Conectar desde Cursor

Abre Configuración → Servidores MCP → Editar JSON.
Agrega o actualiza la entrada mcp-gopls:

{
  "mcpServers": {
    "mcp-gopls": {
      "command": "mcp-gopls",
      "args": ["--workspace", "/absolute/path/to/your/go/project"],
      "env": {
        "MCP_GOPLS_LOG_LEVEL": "info"
      }
    }
  }
}

Ejecuta Developer: Reload Window para que Cursor se reconecte.
Abre el cajón Tools en Cursor Chat y habilita mcp-gopls.

2. Invocar las herramientas

Herramienta / Prompt	Ejemplo de solicitud en Cursor Chat
`go_to_definition`	"Usa `go_to_definition` en `pkg/server/server.go:42`."
`find_references`	"Pide a la herramienta referencias de `ServeStdio`."
`check_diagnostics`	"Solicita diagnósticos para `cmd/mcp-gopls/main.go`."
`get_hover_info`	"Llama a `get_hover_info` en `pkg/tools/workspace.go:88`."
`get_completion`	"Activa autocompletados en `pkg/server/server.go:55`."
`format_document`	"Ejecuta el formateador sobre `pkg/tools/refactor.go`."
`rename_symbol`	"Renombra `clientFactory` a `newClientFactory` mediante la herramienta."
`list_code_actions`	"Lista acciones de código para `pkg/server/server.go:80-90`."
`search_workspace_symbols`	"Busca símbolos del espacio de trabajo para `NewWorkspaceConfig`."
`analyze_coverage`	"Ejecuta `analyze_coverage` para `./pkg/...` con estadísticas por función."
`run_go_test`	"Ejecuta `run_go_test` en `./cmd/...`."
`run_go_mod_tidy`	"Invoca `run_go_mod_tidy` para sincronizar go.mod."
`run_govulncheck`	"Ejecuta `run_govulncheck` y transmite los hallazgos."
`module_graph`	"Llama a `module_graph` para inspeccionar dependencias."
`summarize_diagnostics`	"Usa el prompt `summarize_diagnostics` con los diagnósticos más recientes."
`refactor_plan`	"Alimenta a `refactor_plan` con el JSON de diagnósticos para planificar correcciones."

Ejemplos de Configuración del Cliente

Claude Desktop (macOS, Windows, Linux)

Instala mcp-gopls y asegúrate de que esté en tu $PATH.
Crea o edita claude_desktop_config.json.
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Linux: ~/.config/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Agrega la entrada del servidor:

{
  "mcpServers": {
    "mcp-gopls": {
      "command": "mcp-gopls",
      "args": ["--workspace", "/absolute/path/to/your/go/project"],
      "env": {
        "MCP_GOPLS_LOG_LEVEL": "info"
      }
    }
  }
}

Reinicia Claude Desktop, abre un chat y pídele que se conecte a la herramienta mcp-gopls (Claude mostrará una pestaña "Tools" una vez que se detecte el servidor). Los prompts típicos incluyen "lista diagnósticos para cmd/api/server.go" o "renombra userService a accountService."

Cursor IDE

En Cursor abre Configuración → Servidores MCP → Editar JSON (esto escribe en ~/.cursor/config.json o en la anulación local del proyecto). Agrega:

{
  "mcpServers": {
    "mcp-gopls": {
      "command": "mcp-gopls",
      "args": ["--workspace", "/absolute/path/to/your/go/project"]
    }
  }
}

Recarga Cursor (o ejecuta el comando Developer: Reload Window) y el servidor aparecerá dentro del cajón "Tools". Ahora puedes pedirle a Cursor Chat cosas como "ejecuta go test ./pkg/server con cobertura" o "muestra información hover para pkg/tools/tests.go:42."

GitHub Copilot (Modo Agente)

El Modo Agente de GitHub Copilot puede comunicarse con servidores MCP locales en VS Code, IDEs JetBrains, Eclipse y Xcode (docs). Para conectar mcp-gopls en VS Code:

Actualiza GitHub Copilot (requiere VS Code 1.99+), opta por Modo Agente.
Crea .vscode/mcp.json en tu espacio de trabajo (o edita el archivo global que se muestra en el diálogo "Edit config" de Copilot).
Agrega:

{
  "servers": {
    "mcp-gopls": {
      "type": "stdio",
      "command": "mcp-gopls",
      "args": ["--workspace", "/absolute/path/to/your/go/project"],
      "env": {
        "MCP_GOPLS_LOG_LEVEL": "warn"
      }
    }
  }
}

Recarga el Modo Agente (actívalo/desactívalo) para que Copilot descubra la nueva herramienta; el selector de "Tools" del chat ahora expondrá cada acción MCP (run_go_test, run_govulncheck, etc.). JetBrains y otros IDEs comparten el mismo esquema JSON a través de su panel de configuración de Copilot.

MCP Inspector / Pruebas CLI

Para pruebas rápidas o demostraciones puedes usar mark3labs/mcp-inspector:

npx -y @mark3labs/mcp-inspector \
  --command mcp-gopls \
  --args "--workspace" "/absolute/path/to/your/go/project"

El inspector te permite llamar cada herramienta/recurso/prompt manualmente, lo cual es útil para depurar la configuración del servidor antes de conectarlo a un asistente de IA.

Herramientas MCP

Herramienta	Descripción
`go_to_definition`	Navega a la definición de un símbolo
`find_references`	Lista todas las referencias de un símbolo
`check_diagnostics`	Obtiene diagnósticos en caché para un archivo
`get_hover_info`	Devuelve markdown hover para un símbolo
`get_completion`	Devuelve etiquetas de autocompletado en una posición
`format_document`	Devuelve ediciones de formato para un documento completo
`rename_symbol`	Devuelve ediciones del espacio de trabajo para un renombrado
`list_code_actions`	Lista acciones de código disponibles para un rango
`search_workspace_symbols`	Busca símbolos en todo el espacio de trabajo
`analyze_coverage`	Ejecuta `go test` con cobertura + informe opcional por función
`run_go_test`	Ejecuta `go test` para un paquete/patrón
`run_go_mod_tidy`	Ejecuta `go mod tidy`
`run_govulncheck`	Ejecuta `govulncheck ./...`
`module_graph`	Devuelve la salida de `go mod graph`

Notificaciones de Progreso

Las herramientas de larga duración emiten eventos estructurados notifications/progress para que los IDEs puedan mostrar indicadores de estado enriquecidos:

Progreso en streaming (run_go_test, analyze_coverage, run_govulncheck, run_go_mod_tidy) reenvía líneas de registro incrementales y actualizaciones de porcentaje. Cursor los muestra como un registro en vivo.
Solo eventos de inicio/cierre (go_to_definition, find_references, rename_symbol, etc.) disparan un evento rápido de "iniciado" para que la interfaz pueda mostrar un indicador de actividad, seguido de un payload de finalización con el resultado final.
Cada token de progreso ahora tiene un espacio de nombres (por ejemplo, run_go_test/<rand>) para evitar errores de "token desconocido" cuando varias herramientas se ejecutan simultáneamente.

Al integrar nuevas herramientas, opta por el modo de streaming solo si el comando LSP/golang subyacente produce salida intermedia significativa; de lo contrario, mantente en el flujo ligero de inicio/fin para minimizar el ruido.

Instrucciones de Prompt

Ambos prompts son accesibles desde cualquier cliente compatible con MCP a través del catálogo "Prompts".

`summarize_diagnostics`

Cuándo usarlo: Después de check_diagnostics o run_go_test para convertir diagnósticos sin procesar en pasos accionables.
Argumentos: Ninguno. El servidor lee automáticamente el último payload de diagnósticos almacenado en caché por la capa de herramientas.
Flujo de trabajo típico: check_diagnostics → copia el array devuelto en el campo de entrada del prompt (la interfaz de Cursor lo pega automáticamente cuando seleccionas "Usar último resultado").

`refactor_plan`

Cuándo usarlo: Ya tienes un array JSON de diagnósticos y deseas una lista de cambios concisa.
Argumentos: Requiere un objeto diagnostics que contenga los diagnósticos Go sin procesar (el mismo payload devuelto por check_diagnostics).
Ejemplo de payload de invocación:

{
  "diagnostics": [
    {
      "uri": "file:///path/to/pkg/tools/workspace.go",
      "range": {"start": {"line": 12, "character": 5}, "end": {"line": 12, "character": 25}},
      "severity": 1,
      "message": "unused variable testHelper"
    }
  ]
}

El prompt responde con un conjunto numerado de pasos de refactorización junto con comandos de validación sugeridos (go test, analyze_coverage, etc.).

Configuración

El servidor admite varias opciones de configuración mediante banderas de línea de comandos y variables de entorno:

Banderas de Línea de Comandos

Banderas	Predeterminado	Descripción
`--workspace`	`.`	Ruta absoluta a la raíz de tu proyecto Go
`--gopls-path`	`gopls`	Ruta al binario gopls
`--log-level`	`info`	Nivel de registro (`debug`, `info`, `warn`, `error`)
`--rpc-timeout`	`30s`	Tiempo de espera RPC para llamadas LSP
`--shutdown-timeout`	`5s`	Tiempo de espera para apagado elegante

Variables de Entorno

Todas las banderas se pueden configurar mediante variables de entorno con el prefijo MCP_GOPLS_:

Variable de Entorno	Bandeira Equivalente	Descripción
`MCP_GOPLS_WORKSPACE`	`--workspace`	Ruta absoluta a la raíz de tu proyecto Go
`MCP_GOPLS_GOPLS_PATH`	`--gopls-path`	Ruta al binario gopls
`MCP_GOPLS_LOG_LEVEL`	`--log-level`	Nivel de registro (`debug`, `info`, `warn`, `error`)
`MCP_GOPLS_RPC_TIMEOUT`	`--rpc-timeout`	Tiempo de espera RPC para llamadas LSP (p. ej., `30s`, `1m`)
`MCP_GOPLS_SHUTDOWN_TIMEOUT`	`--shutdown-timeout`	Tiempo de espera para apagado elegante

Las banderas de línea de comandos tienen prioridad sobre las variables de entorno.

Solución de Problemas

“column is beyond end of line” – gopls no pudo mapear la posición proporcionada. Confirma que el archivo esté guardado y que la posición use líneas/columnas basadas en cero; ejecuta go fmt para asegurar que las tabulaciones vs. espacios se alineen con las expectativas de gopls.
“no hover information available” – el símbolo podría pertenecer a un archivo generado o a un módulo fuera del espacio de trabajo configurado. Asegúrate de que la bandera --workspace apunte a la raíz del módulo y que go list ./... tenga éxito.
“workspace not initialized” – el servidor no terminó su sincronización inicial. Espera la línea de registro workspace initialized o reinicia mcp-gopls después de eliminar cachés .gopls obsoletas.
Binario run_govulncheck faltante – la herramienta ahora recurre a go run golang.org/x/vuln/cmd/govulncheck@latest, pero la máquina aún necesita acceso de red saliente. Instala el binario manualmente si la alternativa está bloqueada.

Ejemplo de Uso

Uso del servidor con asistentes de IA que admiten MCP:

# Ask the AI to get information about the code
Can you find the definition of the `ServeStdio` function in this project?

# Ask for diagnostics
Are there any errors in my main.go file?

# Ask for information about a symbol
What does the Context.WithTimeout function do in Go?

Desarrollo

git clone https://github.com/hloiseau/mcp-gopls.git
cd mcp-gopls
go mod tidy
go test ./...
go build ./cmd/mcp-gopls

Las pruebas basadas en tablas viven bajo pkg/tools y CI se ejecuta mediante .github/workflows/ci.yml.

Documentación

docs/usage.md – guía de inicio rápido y recorrido del catálogo de herramientas
Los recursos del espacio de trabajo exponen resource://workspace/overview y resource://workspace/go.mod
Los prompts (summarize_diagnostics, refactor_plan) ayudan a los asistentes a producir resultados consistentes

Contribuciones

¡Se aceptan PRs e issues!

Consulta problemas abiertos o crea uno nuevo si encuentras un error o deseas una función.
Ejecuta go test ./... antes de abrir un PR.
Para cambios más grandes (nuevas herramientas, cambios de protocolo), abre primero un issue de diseño para que podamos discutir el enfoque.

Todas las contribuciones deben mantener la cobertura de pruebas y adherirse a las mejores prácticas de Go. Consulta la sección Desarrollo para instrucciones de configuración.

Requisitos Previos

Go 1.25+ (probado con go1.25.4)
gopls instalado (go install golang.org/x/tools/gopls@latest)
Opcional: govulncheck (go install golang.org/x/vuln/cmd/govulncheck@latest)
El servidor fuerza GOTOOLCHAIN=local para su proceso anidado gopls. Si necesitas un toolchain diferente, establece GOTOOLCHAIN en el entorno antes de lanzar mcp-gopls.

Integración con Ollama

Este servidor MCP se puede usar con cualquier herramienta que admita el protocolo MCP. Para la integración con Ollama:

Asegúrate de que Ollama esté en ejecución
El servidor MCP se ejecuta de forma independiente y se comunica a través de stdin/stdout
Configura tu cliente para usar el servidor MCP como proveedor de herramientas

Licencia

Apache License 2.0

MCP LSP Go

Documentación

mcp-gopls – Servidor MCP para Go (gopls)

Resumen

Arquitectura

Características

Comparación de características: mcp-gopls vs MCP integrado de gopls

Estructura del Proyecto

Instalación

Inicio Rápido

Docker / MCP Gateway

Ejecución con Docker

docker-mcp.yaml

Metadatos del catálogo de herramientas

Configuración Detallada del Cliente

1. Conectar desde Cursor

2. Invocar las herramientas

Ejemplos de Configuración del Cliente

Claude Desktop (macOS, Windows, Linux)

Cursor IDE

GitHub Copilot (Modo Agente)

MCP Inspector / Pruebas CLI

Herramientas MCP

Notificaciones de Progreso

Instrucciones de Prompt

summarize_diagnostics

refactor_plan

Configuración

Banderas de Línea de Comandos

Variables de Entorno

Solución de Problemas

Ejemplo de Uso

Desarrollo

Documentación

Contribuciones

Requisitos Previos

Integración con Ollama

Licencia

Comparación de características: `mcp-gopls` vs MCP integrado de `gopls`

`summarize_diagnostics`

`refactor_plan`