你是否曾见过 GitHub Copilot CLI 将一个 JAR 文件解压到临时目录，然后通过 grep 搜索 .class 文件，再从原始字节码中拼凑出 API 签名？这个智能体虽然足智多谋，但在没有语言服务器的情况下，这已经是它能做到的最好程度了。
语言服务器协议（LSP）是支撑 VS Code 等编辑器中“转到定义”、“查找引用”和“类型解析”功能的标准协议。它在终端中同样适用。LSP 配置技能能够为 Copilot CLI 自动安装和配置 LSP 服务器，从而使智能体能够获得关于你代码的精确、结构化的答案，而不是依赖文本搜索的启发式方法。
在这篇文章中，你将了解该技能在底层是如何工作的，看到它生成的配置格式，并为你当前支持的 14 种语言中的任意一种进行配置。
问题：启发式的代码理解
在没有 LSP 服务器的情况下，GitHub Copilot CLI 中的智能体通过文本搜索和二进制提取来反向工程 API 信息。对于一个 Java 项目，这可能会像这样：
# Find the dependency JAR
find ~/.m2/repository -name "*httpclient*.jar"
# Extract it to a temp directory
mkdir /tmp/httpclient && cd /tmp/httpclient
jar xf ~/.m2/repository/org/apache/httpcomponents/httpclient/4.5.14/httpclient-4.5.14.jar
# Search extracted class files for a method
grep -r "execute" --include="*.class" .对于 Python，智能体可能会读取 site-packages 目录下的文件。对于 TypeScript，它会遍历 node_modules 目录。这些基于文本的方法在简单情况下有效，但它们是在对原始文本进行模式匹配，而非真正的语义分析，因此会遗漏泛型、重载和传递类型，并且完全无法查看编译后的字节码。这正是语言服务器所能弥补的差距。
LSP 服务器从结构上解决了这个问题。当智能体发送一个针对某个符号的 textDocument/definition 请求时，语言服务器会返回精确的源代码位置、完全解析后的类型以及签名。
什么是智能体技能？
智能体技能是一组可复用的指令集，用于扩展 AI 编码智能体的能力。技能以带有 YAML 前置元数据的 Markdown 文件定义，并遵循标准结构：触发描述、分步工作流程、参考数据和行为约束。
LSP 配置技能利用此结构引导智能体完成一个多步骤的安装过程，包括检测操作系统、选择合适的包管理器、编写有效的配置以及验证结果。
LSP 配置技能的工作原理
当被触发时，该技能会执行一个七步工作流程：
1. 语言选择
智能体使用 `ask_user` 并提供一组选项，来确定用户需要 LSP 支持哪种语言。这决定了后续所有步骤。
2. 操作系统检测
智能体运行 `uname -s`（或在 Windows 上检查 `$env:OS` / `%OS%`）来确定目标平台。安装命令因操作系统而异。例如，在 macOS 上是 `brew install jdtls`，而在 Linux 上则是从 eclipse.org 下载。
3. LSP 服务器查找
该技能包含一个参考文件（`references/lsp-servers.md`），其中收录了 14 种语言的精选数据：各操作系统的安装命令、二进制文件名以及即用型配置片段。智能体读取此文件并选择匹配的条目。
4. 配置范围
智能体会询问配置应应用于：
- 用户级：`~/.copilot/lsp-config.json`——适用于所有仓库
- 仓库级：仓库根目录下的 `lsp.json` 或 `.github/lsp.json`——限定于单个项目
当两者同时存在时，仓库级配置优先。
5. 安装
智能体运行相应的安装命令。例如：
# TypeScript on any OS
npm install -g typescript typescript-language-server
# Java on macOS
brew install jdtls
# Rust on any OS
rustup component add rust-analyzer6. 配置
智能体将条目写入或合并到所选配置文件中。格式使用一个 `lspServers` 对象，其中每个键是一个服务器标识符：
{
"lspServers": {
"java": {
"command": "jdtls",
"args": [],
"fileExtensions": {
".java": "java"
}
}
}
} 该技能强制执行的键规则：
- `command` 必须在 `$PATH` 中或为绝对路径
- `args` 通常包含 `"--stdio"` 用于标准 I/O 传输（某些服务器如 jdtls 在内部处理此问题）
- `fileExtensions` 将每个扩展名（带前导点号）映射到一个语言标识符
- 配置文件中的现有条目会被保留——智能体执行合并，从不覆盖
7. 验证
智能体运行 `which <binary>`（或在 Windows 上运行 `where.exe`）来确认服务器可访问，然后验证配置文件是否为格式良好的 JSON。
支持的语言
该技能附带一组针对多种编程语言的预定义语言服务器。如果编码智能体遇到尚未映射的服务器，它将搜索合适的服务器并引导你完成手动配置。
设置完成后的变化
一旦配置好 LSP 服务器，CLI 智能体便可以：
- 解析跨依赖的类型——无需再在 JAR 文件或 `node_modules` 中手动搜索
- 跳转到第三方库中的定义，即使源代码未检入仓库。
- 查找项目中某个符号的所有引用。
- 查看任何函数、类或类型的悬停文档。
这意味着智能体在工具调用上花费的时间更少，首次就能生成更准确的代码。对你而言，这意味着无需再等待智能体解压 JAR 文件或在 node_modules 中搜索你的 IDE 已经知道答案的问题，也减少了因误读签名而导致的错误方向。智能体以你在编辑器中“转到定义”时获得的相同结构化理解来推理你的代码，因此你可以交给它更大、更棘手的任务，并信任其结果。
- 下载技能：访问 Awesome Copilot LSP Setup 技能页面，点击下载按钮获取 ZIP 文件。
- 通过运行以下命令将 ZIP 文件解压到 ~/.copilot/skills/：
unzip lsp-setup.zip -d ~/.copilot/skills/- 重启 GitHub Copilot CLI：如果 Copilot CLI 已在运行，请先输入 /exit。然后重新启动 copilot，以便它加载新技能。
- 要求智能体设置语言服务器：例如，“为 Java 设置 LSP”或“为 Python 启用代码智能”。
- 验证：技能安装并配置 LSP 服务器后，再次重启 Copilot CLI（输入 /exit，然后重新启动），运行 /lsp 检查服务器状态，并尝试对某个依赖项中的符号执行“转到定义”。
该技能是 Awesome Copilot 项目的一部分。它是开源的，欢迎贡献和反馈！
Ever watched GitHub Copilot CLI extract a JAR file to a temporary directory, grep through .class files, and piece together an API signature from raw bytecode? The agent is resourceful, but without a language server, that’s the best it can do.
The Language Server Protocol (LSP) is the standard that powers go to definition, find references, and type resolution in editors like VS Code. It works just as well in the terminal. The LSP Setup skill automates the installation and configuration of LSP servers for Copilot CLI, so the agent gets precise, structured answers about your code instead of relying on text search heuristics.
In this post, you’ll learn how the skill works under the hood, see the configuration format it generates, and get set up for any of the 14 languages it supports today.
The problem: heuristic code understanding
Without an LSP server, the agent in GitHub Copilot CLI reverse-engineers API information through text search and binary extraction. For a Java project, that might look like:
# Find the dependency JAR
find ~/.m2/repository -name "*httpclient*.jar"
# Extract it to a temp directory
mkdir /tmp/httpclient && cd /tmp/httpclient
jar xf ~/.m2/repository/org/apache/httpcomponents/httpclient/4.5.14/httpclient-4.5.14.jar
# Search extracted class files for a method
grep -r "execute" --include="*.class" .For Python, the agent might cat files inside site-packages. For TypeScript, it walks node_modules. These text-based approaches work for simple cases, but they’re doing pattern-matching over raw text rather than true semantic analysis, so they miss generics, overloads, and transitive types, and can’t see compiled bytecode at all. That’s exactly the gap a language server close.
An LSP server solves this structurally. When the agent sends a textDocument/definition request for a symbol, the language server returns the exact source location, fully resolved type, and signature.
What is an agent skill?
Agent skill is a reusable instruction set that extends what an AI coding agent can do. Skills are defined in Markdown files with YAML frontmatter and follow a standard structure: trigger descriptions, step-by-step workflows, reference data, and behavioral constraints.
The LSP Setup skill uses this structure to guide the agent through a multi-step installation process, detecting the operating system, choosing the right package manager, writing valid configuration, and verifying the result.
How the LSP Setup skill works
When triggered, the skill executes a seven-step workflow:
1. Language selection
The agent uses ask_user with a set of choices to determine which language the user needs LSP support for. This drives all subsequent steps.
2. Operating system detection
The agent runs uname -s (or checks $env:OS / %OS% on Windows) to determine the target platform. Install commands vary by operating system. For example, brew install jdtls on macOS versus downloading from eclipse.org on Linux.
3. LSP server lookup
The skill includes a reference file (references/lsp-servers.md) with curated data for 14 languages: install commands per operating system, binary names, and ready-to-use config snippets. The agent reads this file and selects the matching entry.
4. Configuration scope
The agent asks whether the config should be:
- User-level:
~/.copilot/lsp-config.json—applies to all repositories - Repository-level:
lsp.jsonat the repository root or.github/lsp.json—scoped to a single project
Repository-level configuration takes precedence when both exist.
5. Installation
The agent runs the appropriate install command. For example:
# TypeScript on any OS
npm install -g typescript typescript-language-server
# Java on macOS
brew install jdtls
# Rust on any OS
rustup component add rust-analyzer6. Configuration
The agent writes or merges an entry into the chosen config file. The format uses a lspServers object where each key is a server identifier:
{
"lspServers": {
"java": {
"command": "jdtls",
"args": [],
"fileExtensions": {
".java": "java"
}
}
}
} Key rules the skill enforces:
commandmust be on$PATHor an absolute pathargstypically includes"--stdio"for standard I/O transport (some servers likejdtlshandle this internally)fileExtensionsmaps each extension (with leading dot) to a language identifier- Existing entries in the config file are preserved — the agent merges, never overwrites
7. Verification
The agent runs which <binary> (or where.exe on Windows) to confirm the server is accessible, then validates the config file is well-formed JSON.
Supported languages
The skill comes with a set of predefined language servers for several programming languages. If the coding agent faces one that it is not mapped out already, it will search for an appropriate server and walk you through manual configuration.
What changes after setup
Once an LSP server is configured, the CLI agent can:
- Resolve types across dependencies — no more grepping through JAR files or
node_modules - Jump to definitions in third-party libraries, even when source isn’t checked into the repository
- Find all references to a symbol across the project
- Read hover documentation for any function, class, or type
This means the agent spends less time on tool calls and produces more accurate code on the first pass. For you, that’s less time waiting while the agent decompiles a JAR file or greps through node_modules to answer a question your IDE already knows, and fewer wrong turns built on a misread signature. The agent reasons about your code with the same structured understanding you get from go-to-definition in your editor, so you can hand it bigger, gnarlier tasks and trust the result.
- Download the skill: visit the Awesome Copilot LSP Setup skill page and click the Download button to get a ZIP file.
- Extract the ZIP to
~/.copilot/skills/by running:
unzip lsp-setup.zip -d ~/.copilot/skills/- Restart GitHub Copilot CLI: if Copilot CLI is already running, type
/exitfirst. Then relaunchcopilotso it picks up the new skill. - Ask the agent to set up a language server: for example, “set up LSP for Java” or “enable code intelligence for Python”.
- Verify: after the skill installs and configures the LSP server, restart Copilot CLI one more time (
/exit, then relaunch), run/lspto check the server status, and try go-to-definition on a symbol from one of your dependencies.
The skill is part of the Awesome Copilot project. It’s open source, so contributions and feedback are welcome!