Mcp Python Refactoring

MCP其他

提供方 slamer59

其他 HTTP · 远程 会话登录 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

Educational Python refactoring assistant with guided suggestions for AI assistants

一句话选型结论

按资料字段整理

Mcp Python Refactoring 属于其他类 MCP 服务器,HTTP · 远程,会话登录,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接复制的远程端点配置。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类其他 传输方式HTTP · 远程 鉴权会话登录 部署方式远程部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 16 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

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

能力标签

python refactoring code analysis mcp server ai assistant code quality static analysis

支持客户端

适用场景

pythonrefactoringcode analysis

安装与配置

HTTP · 远程 会话登录
连远程 HTTPS 端点,通常为 Streamable HTTP
uvx --from git+https://github.com/slamer59/mcp-python-refactoring.git python-refactor server

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

  1. 1
    准备运行环境

    确认你的客户端支持远程端点,并拿到服务地址。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
接入外部数据

把外部系统的数据接进对话。

自动化重复操作

把固定步骤交给模型跑。

补充工具能力

给模型补上它原本没有的能力。

选择建议

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

值得选的地方

  • 资料标注 16 个工具,覆盖面较广,能满足多种调用。
  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 远程端点依赖网络与服务方可用性,注意密钥与调用额度。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Mcp Python Refactoring当前 16 HTTP · 远程 远程部署 有 未标注
gemini-cli 未标注 stdio · 本地进程 本地部署 有 2026-04-13
ext-apps 未标注 stdio · 本地进程 本地部署 有 2026-04-19
northcinder 未标注 stdio · 本地进程 本地部署 有 2026-08-23
fastctx 未标注 stdio · 本地进程 本地部署 有 2026-08-23
quickstart-resources 未标注 stdio · 本地进程 本地部署 有 2026-04-12

服务器档案

其他
字段来自项目仓库与公开索引,中文说明由本站标注
提供方slamer59上游标注的维护方 slamer59
分类其他本站按上游分类展示
连接方式HTTP · 远程连远程 HTTPS 端点,通常为 Streamable HTTP
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型远程部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

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

MCP Python Refactoring

A Model Context Protocol (MCP) server that analyzes Python code and provides guided refactoring suggestions without automatically modifying your code.

Keywords

python refactoring code-analysis mcp-server ai-assistant claude rope radon vulture jedi educational mentoring code-quality static-analysis complexity-analysis

This tool integrates with AI coding assistants (Claude, ChatGPT, Cursor, etc.) to provide intelligent refactoring guidance. Instead of making automatic code changes, it gives you precise instructions on how to improve your Python code, acting as your refactoring mentor.

What This Tool Does

For AI Coding Assistants:
- Provides structured JSON responses with refactoring opportunities
- Identifies long functions, high complexity code, and dead code
- Gives precise line numbers for extract method refactoring
- Uses professional tools for comprehensive analysis

For Developers:
- Get step-by-step refactoring instructions
- Maintain full control over code changes
- Learn refactoring patterns through guided practice
- Improve code quality systematically

How It Differs

Approach This Tool Traditional Refactoring Tools
Integration Works with any LLM/AI assistant IDE-specific or standalone
Guidance Step-by-step instructions with line numbers Automatic changes only
Learning Educational approach teaches patterns No learning component
Control Developer maintains full control Tool makes all decisions

Registry Submissions

This MCP server is available across the entire MCP ecosystem:

Official MCP Registry

Published and Live: registry.modelcontextprotocol.io
- Server name: io.github.slamer59/mcp-python-refactoring
- Discoverable by all MCP-compatible clients

🟡 Docker MCP Registry

Pull Request Submitted: docker/mcp-registry #207
- Will be available as mcp/mcp-python-refactoring on Docker Hub
- Includes enhanced security: signatures, SBOM, provenance tracking
- Integrated into Docker Desktop's MCP Toolkit

🟡 Awesome MCP Servers Lists

Community Curated Lists:
- appcypher/awesome-mcp-servers #180 - Development Tools section
- punkpeye/awesome-mcp-servers #1321 - Code Execution section

📦 Installation Options

Once all registries are live, users can discover via:
- MCP catalog - Official registry search
- Docker Desktop - MCP Toolkit integration
- Community lists - GitHub awesome lists
- Docker Hub - mcp/mcp-python-refactoring (with enhanced security)

Docker Support

Using with Docker MCP Catalog```bash

Pull from Docker Hub (after registry approval)

docker run -i mcp/mcp-python-refactoring

Or build locally

docker build -t mcp-python-refactoring .
docker run -i mcp-python-refactoring


### Dockerfile```dockerfile
FROM python:3.13-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    && rm -rf /var/lib/apt/lists/*

# Copy project files
COPY pyproject.toml README.md ./
COPY src/ ./src/

# Install the package
RUN pip install --no-cache-dir -e .

# Expose MCP server port (optional, for documentation)
EXPOSE 3000

# Run the MCP server
ENTRYPOINT ["python-refactor", "server"]

Installation

Quick Start with uvx (Recommended)```bash

Install and run MCP server directly from GitHub

uvx --from git+https://github.com/slamer59/mcp-python-refactoring.git python-refactor server


### Add to Claude Code (One Command)```bash
# Add to Claude Code MCP configuration
claude-code mcp add mcp-python-refactoring uvx --from git+https://github.com/slamer59/mcp-python-refactoring.git python-refactor server

After running this command, restart Claude Desktop and the Python refactoring tools will be available in your Claude conversations!

Development Installation```bash

Clone and setup for development

git clone https://github.com/slamer59/mcp-python-refactoring.git
cd mcp-python-refactoring
uv sync

Run MCP server locally

python -m mcp_refactoring_assistant server

Or use the entry point after installation

pip install -e .
python-refactor server


## CLI Usage

The `python-refactor-cli` entry point (installed via `uv sync` or `pip install -e .`)
runs every analysis standalone, without an MCP client — useful for scripts,
CI, or driving the tool directly from an agent's shell:```bash
uv run python-refactor-cli --help

Commands are grouped by capability, and together they cover every MCP tool:

Group Commands MCP tool(s)
file analyze, long-functions, extraction analyze_python_file, find_long_functions, get_extraction_guidance
test coverage, tdd analyze_test_coverage, tdd_refactoring_guidance
security scan analyze_security_and_patterns
package analyze, metrics, issues, dependencies analyze_python_package, get_package_metrics, find_package_issues
repo index, query —
uv run python-refactor-cli file long-functions src/app.py --line-threshold 30 --format json
uv run python-refactor-cli file extraction src/app.py --function-name process_order
uv run python-refactor-cli test coverage src/ --test-path tests/ --target-coverage 80
uv run python-refactor-cli test tdd src/app.py --function-name process_order
uv run python-refactor-cli security scan src/app.py --format table
uv run python-refactor-cli package metrics src/mypackage --format json

To list every command with its usage and examples, run python-refactor-cli skills
(or --help). The old flat names (find-long-functions,
security-scan, package-metrics, …) still work as hidden aliases.

Every command supports --format json for machine-readable output.

Working with Agents

This project ships a SKILL.md describing how an agent should call it —
which command to use for which situation, and the JSON output contract.```bash
uv run python-refactor-cli skills # print the skill + every command with examples
uv run python-refactor-cli skill path # print the path to SKILL.md


Point your coding agent (e.g. Claude Code) at the path this prints and ask
it to load the skill file before refactoring Python code in this repo. A
good generic prompt:

> Run `uv run python-refactor-cli skills` and follow that skill for this session.

## Available MCP Tools

### Unified Server

**Single Server**: Both guide-only and apply-changes modes in one server

**Connection Options**:
- **stdin/stdout**: `python-refactor server` (default)
- **Module execution**: `python -m mcp_refactoring_assistant server`

### Tools

#### 1. `analyze_python_code`
Comprehensive analysis with optional automatic refactoring.

**Parameters:**
- `content` (required): Python file content as string
- `mode` (optional): "guide_only" (default) or "apply_changes"
- `file_path` (optional): Path to the file for context
- `line_threshold` (optional): Minimum lines for long functions (default: 20)

**Mode: guide_only** - Returns instructions only
**Mode: apply_changes** - Returns modified code

#### 2. `analyze_security_and_patterns` 🔒 **NEW!**
Comprehensive security scanning and modern Python patterns analysis.

**Parameters:**
- `content` (required): Python file content as string
- `file_path` (optional): Path to the file for context
- `include_security_scan` (optional): Enable security vulnerability scanning (default: true)
- `include_dependency_scan` (optional): Enable dependency vulnerability scanning (default: true)
- `include_modernization` (optional): Enable modern Python pattern suggestions (default: true)

**Features:**
- **Security Analysis**: Detects 20+ vulnerability types (hardcoded secrets, SQL injection, weak crypto, etc.)
- **Dependency Scanning**: Scans project dependencies for known CVEs using pip-audit
- **Modernization**: Suggests modern Python patterns (f-strings, pathlib, enumerate, etc.)
- **Intelligent Prioritization**: Issues ranked by severity and impact
- **Configurable Analysis**: Enable/disable specific scanning types as needed

#### 3. `extract_function`
Extract specific functions with guide or apply mode.

**Parameters:**
- `content` (required): Python file content
- `mode` (optional): "guide_only" or "apply_changes"
- `function_name` (optional): Specific function to target
- `start_line`, `end_line` (for apply_changes): Exact extraction range
- `new_function_name` (for apply_changes): Name for extracted function

#### 4. `quick_analyze`
Fast analysis for immediate refactoring opportunities.

**Parameters:**
- `content` (required): Python file content

**Returns:** Quick summary of long functions and parameter issues

#### 4. `check_types_with_pyrefly`
Advanced type checking and quality analysis using pyrefly.

**Parameters:**
- `content` (required): Python code content to type check

**Returns:** Detailed type errors, quality issues, and improvement suggestions

#### 5. `get_server_capabilities` (Internal)
Returns server capabilities and available analysis tools.

**Returns:** List of available tools: rope, radon, vulture, jedi, libcst, pyrefly, mccabe, complexipy

## Analysis Capabilities

**Code Quality Issues Detected:**
- Functions over 20 lines (extract method opportunities)
- High cyclomatic complexity (>10) using McCabe analysis
- High cognitive complexity (>15) using Complexipy analysis
- Functions with too many parameters (>5)
- Dead/unused code (consolidated suggestions) via Vulture
- Low maintainability index (<20) using Radon metrics
- Type annotation problems detected by Pyrefly
- Large files (>500 lines) with module splitting recommendations
- Files with too many imports (>20) suggesting restructuring

**🔒 Security & Modernization Features (NEW!):**
- **Security Vulnerability Detection**: Comprehensive security scanning using Bandit
- **Dependency Security Analysis**: CVE detection in project dependencies with pip-audit
- **Modern Python Patterns**: Code modernization suggestions using Refurb
- **Unified Analysis**: Intelligent prioritization combining security and modernization
- **Configurable Scanning**: Enable/disable specific analysis types via MCP endpoint

**Additional Analysis Tools:**
- **Performance Analysis**: Bottleneck identification and optimization suggestions
- **Type Hints**: Missing type annotation detection
- **Documentation**: Docstring coverage and quality assessment

**Professional Tools Used:**

**🔧 Core Refactoring Analysis:**
- **Rope**: Professional refactoring analysis and extract method detection
- **Radon**: Code complexity metrics (cyclomatic, maintainability index)
- **Vulture**: Dead code detection and unused import analysis
- **Jedi**: Semantic code analysis and variable tracking
- **LibCST**: Syntax tree manipulation for precise code analysis
- **Pyrefly**: Advanced type checking and quality analysis
- **McCabe**: Cyclomatic complexity measurement
- **Complexipy**: Advanced complexity analysis and cognitive complexity

**🔒 Security & Modernization Tools (NEW!):**
- **Bandit**: AST-based security vulnerability scanner (20+ vulnerability types)
- **pip-audit**: Dependency vulnerability scanner with CVE database
- **Refurb**: Modern Python pattern suggestions and code modernization

**📁 Built-in Analysis:**
- **File Analysis**: File size analysis and module splitting recommendations
- **Package Analysis**: Comprehensive package structure and dependency analysis

## Testing and Debugging

### Test with MCP Inspector```bash
# Launch MCP Inspector
bunx @modelcontextprotocol/inspector

# In the web interface:
# Command: python
# Args: -m mcp_refactoring_assistant server
# Working Directory: /path/to/your/project

Test Both Modes in Inspector:

Guide Mode Test:```json
{
"content": "def long_function():\n print('line1')\n # ... 20+ lines",
"mode": "guide_only"
}


**Apply Mode Test:**```json
{
  "content": "def long_function():\n    print('line1')\n    # ... 20+ lines",
  "mode": "apply_changes"
}

Test with Bun (Fastest)```bash

Install Bun if not available

curl -fsSL https://bun.sh/install | bash

Install MCP SDK

bun install -g @modelcontextprotocol/sdk

Run tests

export PATH=.venv/bin:$PATH && bun run test_unified.js


### Test Standalone (No MCP)```bash
# Simple Python test
python test_tool.py

# Test with example file
python -m mcp_refactoring_assistant --help

Debug Server Issues```bash

Check dependencies

uv sync

Verify MCP imports

python -c "import mcp; print('MCP available')"

Test individual tools

python -c "
from src.mcp_refactoring_assistant.server import EnhancedRefactoringAnalyzer
analyzer = EnhancedRefactoringAnalyzer()
print('Analyzer working')
"


## Example Usage

### Educational Workflow
1. AI assistant calls `analyze_python_code` with `guide_only` mode
2. Tool returns structured suggestions with precise steps
3. Developer follows step-by-step instructions
4. Developer learns refactoring patterns through practice

### Productivity Workflow
1. AI assistant calls `analyze_python_code` with `apply_changes` mode
2. Tool returns modified code with applied refactorings
3. Developer reviews changes and applies as needed
4. Faster refactoring for experienced developers

### Sample MCP Response (Guide Mode)```json
{
  "analysis_summary": {
    "total_issues_found": 2,
    "medium_priority": 1,
    "low_priority": 1
  },
  "refactoring_guidance": [
    {
      "issue_type": "extract_function",
      "location": "Function 'process_data' lines 45-78",
      "description": "Long function (34 lines) with extractable blocks",
      "precise_steps": [
        "SELECT lines 45-52 (validation block)",
        "CREATE function: validate_input(data)",
        "REPLACE with: is_valid = validate_input(data)"
      ]
    },
    {
      "issue_type": "dead_code",
      "location": "Multiple locations (6 items)",
      "description": "6 unused items found",
      "precise_steps": [
        "Review all unused items listed below:",
        "• Line 11: Unused import 're'",
        "• Line 12: Unused import 'Optional'",
        "Verify each item is truly unused",
        "Remove confirmed unused code"
      ]
    }
  ]
}

Integration with Coding Assistants

Claude Code/CLI

Add to your MCP configuration:```json
{
"servers": {
"python-refactoring": {
"command": "uvx",
"args": ["--from", "git+https://github.com/slamer59/mcp-python-refactoring.git", "python-refactor", "server"]
}
}
}


Or for local installation:```json
{
  "servers": {
    "python-refactoring": {
      "command": "python",
      "args": ["-m", "mcp_refactoring_assistant", "server"]
    }
  }
}

Claude Desktop

Add to claude_desktop_config.json:```json
{
"mcpServers": {
"python-refactoring": {
"command": "uvx",
"args": ["--from", "git+https://github.com/slamer59/mcp-python-refactoring.git", "python-refactor", "server"]
}
}
}


Or for local installation:```json
{
  "mcpServers": {
    "python-refactoring": {
      "command": "python",
      "args": ["-m", "mcp_refactoring_assistant", "server"]
    }
  }
}

Cline (VSCode Extension)

In VSCode settings or .vscode/settings.json:```json
{
"cline.mcpServers": {
"python-refactoring": {
"command": "python",
"args": ["-m", "mcp_refactoring_assistant", "server"]
}
}
}


### Cursor
Add to Cursor's MCP configuration:```json
{
  "mcpServers": {
    "python-refactoring": {
      "command": "python",
      "args": ["-m", "mcp_refactoring_assistant", "server"]
    }
  }
}

Continue (VSCode Extension)

In ~/.continue/config.json:```json
{
"mcpServers": [
{
"name": "python-refactoring",
"command": "python",
"args": ["-m", "mcp_refactoring_assistant", "server"]
}
]
}


### Windsurf
Add to Windsurf MCP configuration:```json
{
  "servers": {
    "python-refactoring": {
      "command": "python",
      "args": ["-m", "mcp_refactoring_assistant", "server"]
    }
  }
}

Aider

Use with MCP bridge or direct integration:```bash
aider --mcp-server "python -m mcp_refactoring_assistant server"


### OpenHands (formerly OpenDevin)
In OpenHands configuration:```yaml
mcp_servers:
  python-refactoring:
    command: python
    args: ["-m", "mcp_refactoring_assistant", "server"]

Roo-Code

Add to Roo-Code's MCP settings:```json
{
"mcpServers": {
"python-refactoring": {
"command": "python",
"args": ["-m", "mcp_refactoring_assistant", "server"]
}
}
}


### Codex CLI
Add to `~/.codex/config.toml`:```toml
[mcp_servers.python-refactoring]
command = "python"
args = ["-m", "mcp_refactoring_assistant", "server"]

Terminal-based clients

For most terminal-based MCP clients:```bash

With uvx

client-name --mcp-server "uvx --from git+https://github.com/slamer59/mcp-python-refactoring.git python-refactor server"

With local installation

client-name --mcp-server "python -m mcp_refactoring_assistant server"


### SSE Mode (Web-based clients)
For web-based clients that support SSE connections:

1. Start the server in SSE mode:```bash
# SSE mode is not currently supported
# Use stdin/stdout mode instead
python-refactor server
  1. Use stdin/stdout connection instead of SSE

Using with mcpo (ChatGPT and others)

For clients without native MCP support:```bash

Install mcpo

pip install mcpo

Bridge MCP to OpenAI-compatible API

mcpo --mcp-server "python -m mcp_refactoring_assistant server" --port 8080
```

Then configure your client to use http://localhost:8080 as API endpoint.

Notes

  • Use python -m mcp_refactoring_assistant server for local installations
  • For uvx installation, use the full uvx command instead of local paths
  • Some clients may require additional configuration or have different syntax
  • Always use absolute paths when specifying python executable
  • Test the connection with the client's MCP debugging tools if available

How It Works

  1. Analysis: Server analyzes Python code using multiple professional tools
  2. Detection: Identifies specific refactoring opportunities with metrics
  3. Guidance: Provides precise line numbers and step-by-step instructions
  4. Integration: AI assistant interprets results and guides developer
  5. Control: Developer maintains full control over all code changes

User Feedback

Users report significant improvements in code quality understanding and refactoring skills when using this tool with AI assistants. The guided approach helps developers learn refactoring patterns while maintaining control over code changes.

"Finally, a tool that teaches me refactoring instead of doing it for me"
"The precise line numbers make it easy to follow the suggestions"
"Game changer for working with legacy code"

Troubleshooting

MCP Connection Issues:
- Ensure all dependencies installed: uv sync
- Check Python path: which python
- Verify MCP import: python -c "import mcp"

Analysis Not Working:
- Test analyzer directly: python test_tool.py
- Check file permissions
- Verify example file exists: ls examples/

Tool Responses Empty:
- Check if code has functions to analyze (minimum complexity threshold)
- Increase line threshold for testing: "line_threshold": 10
- Verify file syntax is valid Python
- Ensure virtual environment is activated

SSE Connection Issues:
- Verify port is not in use: netstat -an | grep 3001
- Check firewall settings for local connections
- Ensure Starlette and Uvicorn are installed: uv add starlette uvicorn

Performance Issues:
- For large codebases (>100 files), consider using file-specific analysis
- Increase timeout settings in MCP client configuration
- Use quick_analyze for immediate feedback on specific functions

Community Registries

Submit to awesome lists and community catalogs:
- MCPServers.org - Create GitHub issue
- Awesome MCP Servers - Submit PR
- Wong2's Awesome List - Submit PR

🆕 Recent Major Updates

Version 2.0: Security & Modernization Features

🎉 What's New:
- 🔒 Security Scanning: Professional-grade vulnerability detection using Bandit
- Detects 20+ security issue types (SQL injection, hardcoded secrets, weak crypto)
- Integrates seamlessly with existing refactoring analysis

  • 📦 Dependency Security: CVE scanning with pip-audit
  • Scans project dependencies for known vulnerabilities
  • Provides specific version upgrade recommendations

  • ⚡ Code Modernization: Python pattern suggestions using Refurb

  • Suggests modern Python features (f-strings, pathlib, enumerate)
  • Helps upgrade legacy code to contemporary best practices

  • 🎯 Unified Analysis: Intelligent prioritization system

  • Combines security, modernization, and refactoring analysis
  • Smart priority ordering by severity and impact
  • Configurable scanning options via new MCP endpoint

  • ✅ Production Ready:

  • 177+ comprehensive tests (100% passing)
  • Extensive error handling and edge case coverage
  • Performance tested on large codebases
  • Full backward compatibility maintained

📊 Proven Results:
- Successfully analyzed and improved itself through iterative refinement
- Reduced code complexity while adding powerful new features
- Enhanced type safety and maintainability throughout the codebase

License

MIT License - Free for personal and commercial use.

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Mcp Python Refactoring 怎么安装?

在客户端按下面的安装命令接入:uvx --from git+https://github.com/slamer59/mcp-python-refactoring.git python-refactor server。装完在客户端配置里引用同一个包或端点。

Mcp Python Refactoring 怎么在 Claude Desktop、Claude、Cursor 里配置?

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

Mcp Python Refactoring 收费吗?

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

Mcp Python Refactoring 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

Mcp Python Refactoring 支持哪些客户端?

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

Mcp Python Refactoring 能提供哪些能力?

资料显示约 16 个工具;能力标签包括 python、refactoring、code analysis、mcp server、ai assistant、code quality。具体工具清单以官方文档为准。

Mcp Python Refactoring 需要什么运行环境?

运行时为 Cross-platform;属于远程端点,不需要在本地装运行时。

Mcp Python Refactoring 是本地还是远程?

它是远程端点,连服务地址即可。传输方式为HTTP · 远程。

热门专题

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

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