MCP Server Poc 903e6ec8

MCP开发工具

提供方 ankittk

开发工具 stdio · 本地进程 无需鉴权 社区 / 第三方 VS Code
查看接入方式

MCP协议服务器实现AI助手与外部工具和数据源的标准化连接,支持工具发现、模式验证和JSON-RPC 2.0格式通信。

一句话选型结论

按资料字段整理

MCP Server Poc 903e6ec8 属于开发工具类 MCP 服务器,stdio · 本地进程,无需鉴权,可直接接入 VS Code,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式stdio · 本地进程 鉴权无需鉴权 部署方式本地部署
GitHub 星标 0 仓库热度,无公开仓库时显示未标注
工具数 5 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量5暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

AI工具集成Python本地部署JSON-RPC协议工具发现模式验证开发工具

安装与配置

stdio · 本地进程 无需鉴权
客户端在本机拉起子进程,数据不出本机
Python MCP server is running at http://localhost:8081

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Python,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后客户端会列出约 5 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 资料标注 5 个工具,职责相对集中,接入后不容易误操作。
  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 VS Code,换客户端不用重新研究配置。
  • 资料标注无需鉴权,装好就能连。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 VS Code 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
MCP Server Poc 903e6ec8当前 5 stdio · 本地进程 本地部署 有 2026-05-17
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方ankittk上游标注的维护方 ankittk
分类开发工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式无需鉴权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Python本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

14.5 KB
来自项目仓库与上游目录的原文,未做删改

MCP Agent Server

Model Context Protocol (MCP) server with Python backend and Go CLI client.

What is MCP Protocol

Model Context Protocol (MCP) is a standardized protocol for AI assistants to connect to external tools and data sources. It's different from simple JSON HTTP APIs in several key ways:

MCP vs Simple JSON HTTP

Simple JSON HTTP API:```json
POST /api/file
{
"action": "read",
"path": "test.txt"
}


**MCP Protocol (JSON-RPC 2.0):**```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "file_operations",
    "arguments": {
      "operation": "read",
      "path": "test.txt"
    }
  }
}

Key Differences

  1. Standardized Structure: MCP uses JSON-RPC 2.0 with required fields (jsonrpc, id, method, params)
  2. Tool Discovery: MCP servers expose available tools via tools/list method
  3. Schema Validation: Each tool has defined input/output schemas
  4. Error Handling: Standardized error codes and messages
  5. AI Integration: Designed specifically for AI assistant tool calling

Performance & Overhead Analysis

JSON Structure Overhead

  • Simple JSON: ~50 bytes payload
  • MCP Protocol: ~150 bytes payload (3x larger)
  • Overhead: ~100 bytes per request

Processing Overhead

  • Simple JSON: Direct parameter extraction
  • MCP Protocol: JSON-RPC parsing + method routing + schema validation
  • Additional CPU: ~2-5ms per request

Network Performance

  • Simple JSON: Single endpoint, no discovery needed
  • MCP Protocol: Initial tool discovery + subsequent calls
  • Latency Impact: +1 round trip for tool discovery

Real-World Impact

  • Low-volume: Negligible difference (< 1ms)
  • High-volume: MCP overhead becomes noticeable
  • AI Integration: MCP benefits outweigh overhead

Where MCP Runs

  • Transport Layer: HTTP, WebSocket, or stdio
  • This Project: Uses HTTP on localhost:8081
  • Production: Often runs in AI development environments (VS Code, etc.)

Request Flow: How GitHub Copilot Calls MCP Server

The following comprehensive diagram illustrates the complete flow of how GitHub Copilot's AI model processes user requests and calls your MCP server:```mermaid
%% Dark-theme optimized
flowchart TD
%% User Input
A[User Request: Read the contents of README.md] --> B{Copilot AI Analysis}

%% Initial Setup
B --&gt; C{Is MCP Server Running?}
C --&gt;|No| D[Start MCP Server: python3 mcp_server.py]
C --&gt;|Yes| E[Load Tool Definitions: copilot-tools.json]
D --&gt; E

%% Tool Discovery
E --&gt; F[Discover Tools: GET /tools/list]
F --&gt; G[Store Schemas: mcp_file_operations, etc.]

%% NLP and Intent
G --&gt; H[Natural Language Processing]
H --&gt; I[Intent: read file]
I --&gt; J[Entity: README.md]
J --&gt; K[Action: read operation]

%% Tool Selection
K --&gt; L{Tool Selection}
L --&gt;|File| M[mcp_file_operations]
L --&gt;|Code| N[mcp_code_analysis]
L --&gt;|Git| O[mcp_git_operations]
L --&gt;|System| P[mcp_system_info]
L --&gt;|Web| Q[mcp_web_search]

%% Parameter Extraction
M --&gt; R[Params:\noperation=read,\npath=README.md]
N --&gt; S[Params:\nfile=file.py,\ntype=quality]
O --&gt; T[Params:\noperation=status]
P --&gt; U[Params:\ninfo_type=all]
Q --&gt; V[Params:\nquery=term]

%% Schema Validation
R --&gt; W[Schema Validation]
S --&gt; W
T --&gt; W
U --&gt; W
V --&gt; W

%% JSON-RPC
W --&gt; X{Valid?}
X --&gt;|Yes| Y[Create JSON-RPC Request]
X --&gt;|No| Z[Ask for Clarification]
Z --&gt; A

Y --&gt; AA[POST to localhost:8081/mcp]
AA --&gt; BB[Payload:\njsonrpc: 2.0,\nid: 1,\nmethod: tools/call,\nparams...]

%% MCP Server
BB --&gt; CC[Process Request]
CC --&gt; DD[Parse JSON-RPC]
DD --&gt; EE[Route to Handler]
EE --&gt; FF[Run Tool]
FF --&gt; GG[Read File]

%% Response
GG --&gt; HH{Success?}
HH --&gt;|Yes| II[Return:\njsonrpc: 2.0,\nresult:\n  content: &#x27;# MCP...&#x27;]
HH --&gt;|No| JJ[Return:\njsonrpc: 2.0,\nerror: File not found]

II --&gt; KK[Process Success]
JJ --&gt; KK
KK --&gt; LL[Parse Response]
LL --&gt; MM[Format for Chat]
MM --&gt; NN[Display in Chat]

%% Feedback Loop
NN --&gt; OO{Satisfied?}
OO --&gt;|Yes| PP[Done]
OO --&gt;|No| QQ[Retry Tool]
QQ --&gt; L

%% Complex Request
A --&gt; RR{Complex Request?\ne.g. analysis}
RR --&gt;|Yes| SS[Decompose]
SS --&gt; TT[List Files]
SS --&gt; UU[Read README]
SS --&gt; VV[Analyze Code]
SS --&gt; WW[Check Git]
SS --&gt; XX[Get System Info]

TT --&gt; YY[Run Multiple Tools]
UU --&gt; YY
VV --&gt; YY
WW --&gt; YY
XX --&gt; YY

YY --&gt; ZZ[Gather Results]
ZZ --&gt; AAA[Format Combined]
AAA --&gt; NN

%% Dark Theme Styling
classDef userNode fill:#1f3b4d,stroke:#ffffff,stroke-width:2px,color:#ffffff
classDef copilotNode fill:#2e1a47,stroke:#ffffff,stroke-width:2px,color:#ffffff
classDef serverNode fill:#1b5e20,stroke:#ffffff,stroke-width:2px,color:#ffffff
classDef toolNode fill:#3e2723,stroke:#ffffff,stroke-width:2px,color:#ffffff
classDef errorNode fill:#b71c1c,stroke:#ffffff,stroke-width:2px,color:#ffffff

class A,NN,PP userNode
class B,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,AA,BB,KK,LL,MM,OO,QQ,RR,SS,TT,UU,VV,WW,XX,YY,ZZ,AAA copilotNode
class C,D,E,F,G,CC,DD,EE,FF,GG,HH,II,JJ serverNode
class M,N,O,P,Q toolNode
class Z,QQ errorNode

## Architecture

Python server implements MCP protocol on port 8081. Go CLI connects as client via HTTP using JSON-RPC 2.0 format.

## Python MCP Server

Implements tools using HTTP server on localhost:8081. Handles file operations, code analysis, Git operations, system info, and web search.

## Go CLI Client

Fast command-line interface connecting to Python server. Provides interactive access to all MCP tools.

## Why This Project is Different

### Not Just Simple JSON HTTP

This project demonstrates **MCP protocol implementation**, not a basic JSON API:

1. **Tool Discovery**: CLI can discover available tools dynamically
2. **Schema-Aware**: Tools have defined input schemas and validation
3. **Standardized Protocol**: Uses JSON-RPC 2.0 with proper error handling
4. **AI-Ready**: Designed for AI assistant integration
5. **Extensible**: Easy to add new tools with proper schemas

### Simple JSON HTTP Alternative

A basic alternative would be:```bash
curl -X POST http://localhost:8081/api/file \
  -H &quot;Content-Type: application/json&quot; \
  -d &#x27;{&quot;action&quot;: &quot;read&quot;, &quot;path&quot;: &quot;test.txt&quot;}&#x27;

But this lacks tool discovery, schema validation, and AI integration capabilities.

When to Use Each:

Use Simple JSON when:
- High-performance requirements (>1000 req/sec)
- Known API endpoints
- Minimal overhead needed

Use MCP Protocol when:
- AI assistant integration
- Dynamic tool discovery needed
- Schema validation required
- Extensible tool ecosystem

Architecture

Python server implements MCP protocol on port 8081. Go CLI connects as client via HTTP using JSON-RPC 2.0 format.

Usage```bash

make setup
make run


## Agent Examples

### List Available Tools```bash
mcp-cli tools
``````
Fetching available tools from Python MCP server...
Available Tools (5):

1. file_operations
   Perform file operations like read, write, list, and search

2. code_analysis
   Analyze code for quality, issues, and suggestions

3. git_operations
   Perform Git operations like status, commit, push, pull

4. system_info
   Get system information like CPU, memory, disk usage

5. web_search
   Search the web for information

File Operations```bash

mcp-cli file list .

Calling tool: file_operations
Result:
Directory listing for .:
  - go.mod
  - Makefile
  - README.md
  - internal
  - mcp-cli
  - mcp_server.py
  - go.sum
  - cmd
  - requirements.txt
```

### Git Operations```bash
mcp-cli git status

Calling tool: git_operations
Result:
Git error: fatal: not a git repository (or any of the parent directories): .git


### System Information```bash
mcp-cli sys all
``````
Calling tool: system_info
Result:
System Information
CPU Cores: 8
Total Memory: 16384 MB
Disk Usage:
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       500G  150G  350G  30% /

Code Analysis```bash

mcp-cli analyze cmd/cli.go

Calling tool: code_analysis
Result:
Code Analysis for cmd/cli.go
Language: auto
Analysis Type: quality
Lines of Code: 245
Characters: 6542
Empty Lines: 32
Comment Lines: 0
Code Density: 87.0%
```

### Server Status```bash
mcp-cli status

Python MCP server is running at http://localhost:8081


### Interactive Chat```bash
mcp-cli chat

Starts interactive session with tool discovery and command parsing.

Testing```bash

make test-all


Tests Python MCP server and Go CLI endpoints.

## VS Code GitHub Copilot Agent Tools Integration

#### VS Code Configuration

The following configuration files have been created:

- `.vscode/settings.json` - VS Code settings with Copilot agent tools configuration
- `.vscode/tasks.json` - Build and run tasks
- `.vscode/launch.json` - Debug configurations
- `.vscode/extensions.json` - Recommended extensions
- `copilot-tools.json` - Copilot tools definition

#### Start the MCP Server

You can start the MCP server in several ways:

**Option A: Using VS Code Tasks**
1. Open Command Palette (`Ctrl+Shift+P`)
2. Type &quot;Tasks: Run Task&quot;
3. Select &quot;Start MCP Server&quot;

**Option B: Using Terminal**```bash
python3 mcp_server.py

Using Debug Configuration
1. Go to Run and Debug panel (Ctrl+Shift+D)
2. Select "Debug MCP Server"
3. Click the play button

Verify Integration

Check if the server is running:```bash
./mcp-cli status


List available tools:```bash
./mcp-cli tools

Available Tools

1. File Operations (mcp_file_operations)

  • read: Read file contents
  • write: Write content to file
  • list: List directory contents
  • search: Search for files by pattern
  • delete: Delete files or directories

2. Code Analysis (mcp_code_analysis)

  • quality: Analyze code quality metrics
  • security: Check for security issues
  • performance: Analyze performance aspects
  • style: Check coding style and conventions

3. Git Operations (mcp_git_operations)

  • status: Check Git repository status
  • commit: Create commits
  • push: Push changes to remote
  • pull: Pull changes from remote
  • log: View commit history
  • diff: Show differences

4. System Information (mcp_system_info)

  • cpu: CPU information
  • memory: Memory usage
  • disk: Disk usage
  • network: Network status
  • all: All system information

5. Web Search (mcp_web_search)

  • Search the web for information
  • Configurable result count

Using with GitHub Copilot

1. Enable Agent Tools

The integration is configured to automatically enable Copilot agent tools. You can verify this in your VS Code settings:```json
{
"github.copilot.agent.tools.enabled": true,
"github.copilot.agent.tools.autoStart": true
}


#### 2. Using Tools in Chat

In GitHub Copilot Chat, you can now use commands like:

- &quot;Read the contents of `main.go`&quot;
- &quot;Analyze the code quality of `mcp_server.py`&quot;
- &quot;Check the Git status&quot;
- &quot;Get system information&quot;
- &quot;Search for information about MCP protocol&quot;

#### 3. Using Tools in Code

Copilot can now suggest and use these tools when you&#x27;re coding. For example:

- When you ask to read a file, it can use the file operations tool
- When you need system information, it can use the system info tool
- When you need to analyze code, it can use the code analysis tool

### Development Workflow

#### 1. Development Mode

For development, you can use the interactive CLI:```bash
./mcp-cli chat

This starts an interactive session where you can test all tools.

2. Debugging

Use the provided debug configurations:
- "Debug MCP Server" - Debug the Python server
- "Debug MCP CLI" - Debug the Go CLI
- "Debug MCP CLI Chat" - Debug the interactive chat

3. Testing

Test individual tools:```bash

Test file operations

./mcp-cli file read README.md

Test Git operations

./mcp-cli git status

Test system info

./mcp-cli sys all

Test code analysis

./mcp-cli analyze mcp_server.py


### Configuration Files

#### VS Code Settings (`.vscode/settings.json`)
- Configures Copilot agent tools
- Sets up Python and Go environments
- Enables automatic tool startup

#### Tasks (`.vscode/tasks.json`)
- Start/Stop MCP Server
- Build MCP CLI
- Run various CLI commands
- Check server status

#### Launch Configurations (`.vscode/launch.json`)
- Debug configurations for both Python and Go components
- Integrated terminal support
- Environment variable configuration

#### Copilot Tools (`copilot-tools.json`)
- Defines available tools for Copilot
- Specifies input schemas
- Configures server startup

### Troubleshooting

#### Common Issues

1. **Server not starting**:
   - Check if port 8081 is available
   - Verify Python dependencies are installed
   - Check the terminal for error messages

2. **CLI not working**:
   - Ensure the CLI is built: `go build -o mcp-cli ./cmd`
   - Check if the server is running
   - Verify the server URL in CLI configuration

3. **Copilot tools not available**:
   - Restart VS Code
   - Check if GitHub Copilot extension is enabled
   - Verify the settings in `.vscode/settings.json`

#### Debug Commands```bash
# Check server health
curl http://localhost:8081/health

# Test MCP protocol
curl -X POST http://localhost:8081/mcp \
  -H &quot;Content-Type: application/json&quot; \
  -d &#x27;{&quot;jsonrpc&quot;:&quot;2.0&quot;,&quot;id&quot;:1,&quot;method&quot;:&quot;tools/list&quot;,&quot;params&quot;:{}}&#x27;

# Check CLI status
./mcp-cli status

Advanced Configuration

Custom Tool Development

To add new tools:

  1. Add the tool to mcp_server.py in the _register_tools() method
  2. Implement the tool logic in _execute_tool()
  3. Update copilot-tools.json with the new tool definition
  4. Add CLI commands in cmd/cli.go

Environment Variables

You can customize the behavior with environment variables:bash export MCP_SERVER_URL=http://localhost:8081 export MCP_TIMEOUT=30s export PYTHONPATH=/path/to/your/project

Custom Server Configuration

Modify mcp_server.py to:
- Change the server port
- Add authentication
- Implement custom protocols
- Add more sophisticated error handling

Security Considerations

  1. File Access: The file operations tool can access any file on the system
  2. System Information: The system info tool can expose sensitive system data
  3. Network Access: The web search tool makes external network requests
  4. Git Operations: Git operations can modify your repository

Always review and test tools before using them in production environments.

Contributing

To contribute to this integration:

  1. Fork the repository
  2. Create a feature branch
  3. Make your changes
  4. Test thoroughly
  5. Submit a pull request

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
MCP Server Poc 903e6ec8 怎么安装?

在客户端按下面的安装命令接入:Python MCP server is running at http://localhost:8081。装完在客户端配置里引用同一个包或端点。

MCP Server Poc 903e6ec8 怎么在 VS Code 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

MCP Server Poc 903e6ec8 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

MCP Server Poc 903e6ec8 需要 API Key 吗?

资料标注为无需认证,装好就能连;如果实际调用时报鉴权错误,按官方文档补上凭据。

MCP Server Poc 903e6ec8 支持哪些客户端?

资料标注支持 VS Code;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

MCP Server Poc 903e6ec8 能提供哪些能力?

资料显示约 5 个工具;能力标签包括 工具发现、开发工具、Python、VS Code。具体工具清单以官方文档为准。

MCP Server Poc 903e6ec8 需要什么运行环境?

运行时为 Python;属于本地进程,需要在本机装好运行环境。

MCP Server Poc 903e6ec8 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。