Allows executing shell commands and performing file operations on a Linux system.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-linux-ops check disk usage for /var/log"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
这是一个 Model Context Protocol (MCP) 服务器，允许大模型在 Linux 机器上执行各种操作，包括执行命令、文件操作等。
execute_command: 在 Linux 系统上执行 shell 命令
支持指定工作目录
可配置超时时间
返回标准输出、标准错误和退出码
read_file: 读取文件内容
write_file: 写入文件内容（支持追加模式）
list_directory: 列出目录内容
create_directory: 创建目录（支持递归创建）
delete_file: 删除文件或目录
file_exists: 检查文件或目录是否存在
get_file_info: 获取文件或目录的详细信息
copy_file: 复制文件或目录
move_file: 移动或重命名文件或目录
Related MCP server: Linux MCP Server
克隆或下载此项目
安装依赖：
npm install构建项目：
npm run build在 Cursor 的设置中添加 MCP 服务器配置。编辑你的 MCP 配置文件（通常在 ~/.cursor/mcp.json 或类似位置）：
{
"mcpServers": {
"linux-ops": {
"command": "node",
"args": ["/path/to/mcp/dist/index.js"]
}
}
}或者如果你使用 npm 全局安装：
{
"mcpServers": {
"linux-ops": {
"command": "mcp-linux-ops"
}
}
}在开发时，你可以使用 tsx 直接运行：
npm run dev执行 shell 命令并返回结果。
参数：
command (必需): 要执行的 shell 命令
workingDirectory (可选): 执行命令的工作目录
timeout (可选): 命令超时时间（秒，默认 30）
示例：
{
"command": "ls -la",
"workingDirectory": "/home/user",
"timeout": 10
}读取文件内容。
参数：
filePath (必需): 要读取的文件路径
encoding (可选): 文件编码（默认 "utf-8"）
写入文件内容。
参数：
filePath (必需): 要写入的文件路径
content (必需): 要写入的内容
encoding (可选): 文件编码（默认 "utf-8"）
append (可选): 是否追加模式（默认 false）
列出目录内容。
参数：
directoryPath (必需): 要列出的目录路径
includeHidden (可选): 是否包含隐藏文件（默认 false）
创建目录。
参数：
directoryPath (必需): 要创建的目录路径
recursive (可选): 是否递归创建父目录（默认 true）
删除文件或目录。
参数：
path (必需): 要删除的文件或目录路径
recursive (可选): 删除目录时是否递归（默认 false）
检查文件或目录是否存在。
参数：
path (必需): 要检查的文件或目录路径
获取文件或目录的详细信息。
参数：
filePath (必需): 文件或目录路径
复制文件或目录。
参数：
source (必需): 源文件或目录路径
destination (必需): 目标路径
recursive (可选): 复制目录时是否递归（默认 true）
移动或重命名文件或目录。
参数：
source (必需): 源文件或目录路径
destination (必需): 目标路径
⚠️ 警告: 此服务器允许执行任意 shell 命令，具有与运行用户相同的权限。请确保：
只在受信任的环境中使用
不要在生产环境中以 root 权限运行
考虑添加命令白名单或权限控制
限制可访问的文件系统路径
MIT
复制文件或目录
| Name | Required | Description | Default |
|---|---|---|---|
| source | Yes | 源文件或目录路径 | |
| recursive | No | 复制目录时是否递归（默认 true） | |
| destination | Yes | 目标路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does not mention overwrite behavior, recursive copying by default, or any side effects. The description simply restates the function without revealing how the operation behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise, using a single short phrase with no unnecessary words. However, it is so sparse that it under-specifies, trading completeness for brevity. It is appropriately front-loaded but lacks needed detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of annotations and output schema, the description is too minimal to be contextually complete. It does not explain whether the destination gets overwritten, how directory recursion works, or what errors might occur, leaving significant gaps for a simple file operation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so all three parameters (source, destination, recursive) are fully documented in the schema. The description adds no extra meaning beyond the schema, warranting the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (copy) and the target (file or directory), which is specific and distinguishes it from sibling tools like move_file or delete_file. Even though it is brief, it unambiguously identifies the tool's core function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as when to prefer copy_file over move_file, nor any prerequisites or exclusions. The usage context is entirely implied by the name and sibling tool list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
创建目录
| Name | Required | Description | Default |
|---|---|---|---|
| recursive | No | 是否递归创建父目录（默认 true） | |
| directoryPath | Yes | 要创建的目录路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action 'create directory' and does not mention recursive creation, overwrite behavior, permissions, error handling, or side effects. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short—just two characters. While it is concise, it borders on under-specification, lacking any explanatory structure or context. It is not as empty as a single-word tautology, but it does not provide adequate information for the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with two parameters, but given the lack of annotations and output schema, the description should provide more context: default recursive behavior, what happens if the directory exists, and potential errors. The current description is incomplete for reliable tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (directoryPath, recursive) and their meanings. The description adds no additional parametric information, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description '创建目录' (Create directory) clearly states the verb and resource, distinguishing it from sibling file tools like read_file or write_file. However, it is extremely minimal and does not elaborate on scope or specifics, missing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. Sibling tools exist (e.g., execute_command, write_file), but there is no mention of selection criteria, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
删除文件或目录
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | 要删除的文件或目录路径 | |
| recursive | No | 删除目录时是否递归（默认 false） |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as irreversibility of deletion, permission requirements, or the need for the recursive flag when deleting directories. This is a significant gap for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wasted words, but it is under-specified. It lacks important context about behavior and usage, making it minimally concise rather than effectively structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature and lack of annotations or output schema, the description is insufficient. It does not explain return values, error conditions, or safety considerations, leaving the agent without critical context for a deletion operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents both parameters (path and recursive) with descriptions and defaults. The description itself adds no extra parameter details, but it does not need to because the schema coverage is complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool deletes a file or directory, which is a specific verb and resource. It is distinguishable from sibling tools like copy_file and move_file, though it lacks any additional scope clarification (e.g., permanent deletion).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as using execute_command for more complex deletion operations or move_file for a safer 'trash' approach. There is no mention of prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
在 Linux 系统上执行 shell 命令
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | 要执行的 shell 命令 | |
| timeout | No | 命令超时时间（秒，默认 30） | |
| workingDirectory | No | 执行命令的工作目录（可选） |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for disclosing behavioral traits. However, it does not mention side effects, permissions, output handling, or the risks of executing arbitrary shell commands, leaving the agent with little awareness of consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no filler, effectively front-loading the core purpose. It could benefit from more detail, but it is appropriately structured for a brief tool summary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool can execute arbitrary shell commands, yet the description omits critical context such as environment, working directory behavior, output capture, or error handling. With no output schema and no annotations, the one-line description is insufficient for confident invocation, especially given the tool's potentially broad impact.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter-specific meaning beyond what the schema already provides, but it does not need to since all parameters are well-described in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('执行' / execute) and resource ('shell 命令' / shell commands) on a specific platform (Linux), distinguishing it from the file-operation sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention exclusions, prerequisites, or appropriate contexts. It simply states what the tool does without framing its usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
检查文件或目录是否存在
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | 要检查的文件或目录路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description does not disclose return behavior (e.g., whether it returns a boolean), error handling, symlink behavior, or whether it distinguishes between files and directories. The agent is left guessing the exact semantics of the existence check.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately states the core function. It is appropriately sized and front-loaded, with no extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of an output schema and annotations, the description should explain what the tool returns (e.g., true/false) or how the result is conveyed. This is missing, making the tool incomplete for an agent that needs to interpret the outcome.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides 100% coverage for the only parameter, 'path', with the description '要检查的文件或目录路径'. The tool description adds no additional semantic meaning beyond the schema, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: '检查文件或目录是否存在' (check whether a file or directory exists). It uses a specific verb and resource, and it is distinct from sibling tools like read_file or get_file_info, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as whether to use get_file_info for more detailed checks. There is no mention of preconditions, exclusions, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
获取文件或目录的详细信息
| Name | Required | Description | Default |
|---|---|---|---|
| filePath | Yes | 文件或目录路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only says 'get detailed information' without disclosing behavioral traits such as return format, error handling, permissions, or whether it follows symlinks. The read-only nature is implied but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words, making it concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no description of what 'detailed information' includes, an agent cannot know what the tool returns. The description is too sparse for a tool with no annotations or output schema, leaving the agent to guess about return values and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides full coverage of the single filePath parameter with a description. The tool description adds no additional context about parameter format, examples, or edge cases, so it provides no value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves detailed information about a file or directory, using a specific verb (获取) and resource. This distinguishes it from sibling tools like read_file (content) and list_directory (listing), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as file_exists or read_file. The description lacks any context about use cases, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
列出目录内容
| Name | Required | Description | Default |
|---|---|---|---|
| directoryPath | Yes | 要列出的目录路径 | |
| includeHidden | No | 是否包含隐藏文件（默认 false） |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only restates the tool's basic function and does not mention return format, whether hidden files are included by default (though schema indicates default false), error handling, or whether listing is recursive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise—a single sentence—but it lacks necessary contextual structure. It is appropriately short for the simple function, yet under-specifies behavioral details that would help an agent use the tool correctly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool, the description is incomplete given no output schema and no annotations. It does not explain what the returned data looks like, whether it is sorted, or any edge-case behavior. It also provides no guidance on when to invoke this tool over siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are documented with descriptions. The tool description adds no additional parameter context beyond the schema, which is acceptable given the high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description '列出目录内容' (List directory contents) clearly states the action (list) and resource (directory contents). It is specific enough to distinguish from sibling tools like read_file or execute_command, which operate on file content or shell commands respectively.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, typical scenarios, or explicit exclusion of cases where other tools (e.g., read_file) would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
移动或重命名文件或目录
| Name | Required | Description | Default |
|---|---|---|---|
| source | Yes | 源文件或目录路径 | |
| destination | Yes | 目标路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior. It only says 'move or rename' without specifying key traits such as source deletion, overwrite behavior, permissions, or return values. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence that is front-loaded and contains no redundant information. It efficiently communicates the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with complete parameter schema, but the description lacks information about behavioral outcomes (e.g., source is removed, destination overwrite rules) and return behavior. This is adequate but leaves clear gaps that an agent would need to infer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and both parameters are clearly described in the schema. The tool description adds no extra parameter semantics beyond what the schema already provides (e.g., 'file or directory' is already in the schema's property description). Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action with a specific verb ('move/rename') and resource ('file or directory'), distinguishing it from sibling tools like copy_file or delete_file. It unambiguously communicates the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (for moving or renaming files/directories) and implicitly differentiates from copying (copy_file), but it does not explicitly name alternatives or state when not to use it. Context is clear but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
读取文件内容
| Name | Required | Description | Default |
|---|---|---|---|
| encoding | No | 文件编码（默认 utf-8） | utf-8 |
| filePath | Yes | 要读取的文件路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only says 'read file content' and does not disclose error handling, return format, encoding behavior, or side effects. This is insufficient for an agent to understand tool behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief, consisting of a single phrase. While it is front-loaded, it is under-specified and lacks necessary usage and behavioral details, making it insufficient rather than appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description must explain return values and usage context. It only states 'read file content' without addressing what is returned, error cases, or when to use this tool, leaving the agent without sufficient operational knowledge.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover 100% of parameters (filePath and encoding), so the baseline is 3. The description adds no additional semantic meaning beyond the schema, and does not compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description '读取文件内容' clearly states the tool reads file content with a specific verb and resource, distinguishing it from write/delete operations. However, it does not explicitly differentiate from sibling tools like get_file_info or list_directory, which could also be used for file exploration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as get_file_info, list_directory, or execute_command. The description only states the action without context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
写入文件内容
| Name | Required | Description | Default |
|---|---|---|---|
| append | No | 是否追加模式（默认 false） | |
| content | Yes | 要写入的内容 | |
| encoding | No | 文件编码（默认 utf-8） | utf-8 |
| filePath | Yes | 要写入的文件路径 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description merely restates the tool's function without disclosing any behavioral traits such as overwrite semantics, file creation behavior, or error handling. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, making it concise and front-loaded. However, it is so minimal that it borders on under-specification, providing no additional value beyond the tool name, similar to a tautology.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a file-writing tool with no annotations and no output schema, the description is incomplete. It fails to explain default overwrite behavior, whether directories are created, or what occurs on success or failure. The schema covers parameters but not the operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all four parameters (filePath, content, append, encoding) documented in the input schema. The description itself adds no extra parameter context, but the baseline score of 3 is justified since the schema adequately covers semantic meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description '写入文件内容' translates to 'Write file content', clearly stating the tool's function with a specific verb and resource. It distinguishes from siblings like read_file, delete_file, and copy_file, though it doesn't explicitly contrast with them, so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives like execute_command or create_directory. There is no mention of use cases, prerequisites, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0copy_filecreate_directorydelete_fileexecute_commandfile_existsget_file_infolist_directorymove_fileread_filewrite_fileEach tool maps to a distinct action (execute, read, write, list, create, delete, check, info, copy, move), with no overlap. Even though file and directory operations are combined in some tools, descriptions clarify that they handle both, eliminating ambiguity.
Most tools follow a consistent verb_noun pattern (e.g., read_file, create_directory, copy_file). The only exception is file_exists, which uses noun_verb, creating a minor inconsistency that prevents a perfect score.
10 tools is well within the ideal range for a Linux file operations server. Each tool covers a distinct operation with no redundancy, and the count feels appropriately scoped for the purpose.
The server covers the full lifecycle for files and directories: create, read, write, delete, list, copy, move, check existence, and get info, plus arbitrary command execution. This is a complete surface for the stated domain, with no obvious dead ends or missing critical operations.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
Provides capabilities that let LLM agents perform a range of infrastructure management tasks.
Gateway between LLM agents and world data through eight tools and a bundled endpoint catalog.
Runtime permission, approval, and audit layer for AI agent tool execution.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/zql78/mcp-linux-ops'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
