Caja de herramientas de Python de MCP

Un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona un conjunto integral de herramientas para el desarrollo en Python, lo que permite a los asistentes de IA como Claude trabajar eficazmente con proyectos y códigos de Python.

Descripción general

MCP Python Toolbox implementa un servidor de Protocolo de Contexto de Modelo que permite a Claude realizar tareas de desarrollo en Python a través de una interfaz estandarizada. Esto le permite:

Leer, escribir y administrar archivos dentro de un espacio de trabajo
Analizar, formatear y depurar código Python
Administrar entornos virtuales y dependencias
Ejecutar código Python de forma segura

Características

Operaciones con archivos ( `FileOperations` )

Operaciones seguras con archivos dentro de un directorio de espacio de trabajo
Validación de ruta para evitar acceso no autorizado fuera del espacio de trabajo
Leer y escribir archivos con operaciones específicas de línea
Crear y eliminar archivos y directorios
Listado de contenidos del directorio con metadatos detallados (tamaño, tipo, hora de modificación)
Creación automática de directorio padre al escribir archivos

Análisis de código ( `CodeAnalyzer` )

Analizar la estructura del código Python mediante AST
Extraer información detallada sobre:
- Declaraciones de importación y sus alias
- Definiciones de funciones con argumentos y decoradores
- Definiciones de clases con clases base y métodos
- Asignaciones de variables globales
Formatear código usando:
- Negro (predeterminado)
- PEP8 (usando autopep8)
Análisis completo de código mediante Pylint con informes detallados

Gestión de proyectos ( `ProjectManager` )

Cree y administre entornos virtuales con soporte pip
Gestión flexible de dependencias:
- Instalar desde requirements.txt
- Instalar desde pyproject.toml
- Compatibilidad con versiones de paquetes específicos
Manejo avanzado de dependencias:
- Comprobar si hay conflictos de versiones entre paquetes
- Listar todos los paquetes instalados con versiones
- Actualizar paquetes a versiones específicas
- Generar requirements.txt desde el entorno actual

Ejecución de código ( `CodeExecutor` )

Ejecutar código Python en un entorno controlado
Utiliza el entorno virtual del proyecto para dependencias consistentes
Gestión de archivos temporales para la ejecución de código
Capturar stdout, stderr y códigos de salida
Soporte para directorios de trabajo personalizados

Instalación

Clonar el repositorio:

git clone https://github.com/gianlucamazza/mcp_python_toolbox.git
cd mcp_python_toolbox

Crear y activar un entorno virtual:

python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# or
.venv\Scripts\activate  # Windows

Instalar el paquete en modo de desarrollo:

pip install -e ".[dev]"

Uso

Ejecutarse como una herramienta CLI

La forma más sencilla de iniciar el servidor es usando la CLI:

# Start with current directory as workspace
python -m mcp_python_toolbox

# Or specify a workspace directory
python -m mcp_python_toolbox --workspace /path/to/your/project

Configuración con Claude Desktop

Claude Desktop puede iniciar y administrar automáticamente el servidor MCP Python Toolbox. Aquí se explica cómo configurarlo:

Instale y configure MCP Python Toolbox como se describe arriba
Agregue una entrada de configuración para la Caja de herramientas de Python en la configuración de herramientas MCP de Claude Desktop:

"python-toolbox": {
  "command": "/Users/username/path/to/mcp_python_toolbox/.venv/bin/python",
  "args": [
    "-m",
    "mcp_python_toolbox",
    "--workspace",
    "/Users/username/path/to/workspace"
  ],
  "env": {
    "PYTHONPATH": "/Users/username/path/to/mcp_python_toolbox/src",
    "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
    "VIRTUAL_ENV": "/Users/username/path/to/mcp_python_toolbox/.venv",
    "PYTHONHOME": ""
  }
}

Personaliza las rutas para que coincidan con tu entorno.
Claude Desktop iniciará automáticamente el servidor MCP cuando sea necesario
Claude ahora tendrá acceso a las herramientas de desarrollo de Python a través de la interfaz MCP

Uso programático

from mcp_python_toolbox import PythonToolboxServer

server = PythonToolboxServer(workspace_root="/path/to/your/project")
server.setup()
server.run()

Ejemplos de módulos principales

Operaciones con archivos

from mcp_python_toolbox.core import FileOperations

file_ops = FileOperations(workspace_root="/path/to/project")

# Read file contents
content = file_ops.read_file("src/example.py")
# Read specific lines
lines = file_ops.read_file("src/example.py", start_line=10, end_line=20)

# Write to file
file_ops.write_file("output.txt", "Hello, World!")
# Append to file
file_ops.write_file("log.txt", "New entry\n", mode='a')

# List directory contents
contents = file_ops.list_directory("src")
for item in contents:
    print(f"{item['name']} - {item['type']} - {item['size']} bytes")

Análisis de código

from mcp_python_toolbox.core import CodeAnalyzer

analyzer = CodeAnalyzer(workspace_root="/path/to/project")

# Analyze Python file structure
analysis = analyzer.parse_python_file("src/example.py")
print(f"Found {len(analysis['functions'])} functions")
print(f"Found {len(analysis['classes'])} classes")

# Format code
formatted = analyzer.format_code(code, style='black')

# Lint code
issues = analyzer.lint_code("src/example.py")
for issue in issues:
    print(f"Line {issue['line']}: {issue['message']}")

Gestión de proyectos

from mcp_python_toolbox.core import ProjectManager

pm = ProjectManager(workspace_root="/path/to/project")

# Create virtual environment
pm.create_virtual_environment()

# Install dependencies
pm.install_dependencies()  # from requirements.txt or pyproject.toml
pm.install_dependencies("requirements-dev.txt")  # from specific file

# Check for conflicts
conflicts = pm.check_dependency_conflicts()
if conflicts:
    print("Found dependency conflicts:")
    for conflict in conflicts:
        print(f"{conflict['package']} requires {conflict['requires']}")

# Update packages
pm.update_package("requests")  # to latest
pm.update_package("flask", version="2.0.0")  # to specific version

Ejecución de código

from mcp_python_toolbox.core import CodeExecutor

executor = CodeExecutor(workspace_root="/path/to/project")

code = '''
def greet(name):
    return f"Hello, {name}!"

print(greet("World"))
'''

result = executor.execute_code(code)
print(f"Output: {result['stdout']}")
print(f"Errors: {result['stderr']}")
print(f"Exit code: {result['exit_code']}")

Desarrollo

Ejecución de pruebas

pytest

Comprobación de tipos

mypy src/mcp_python_toolbox

Pelusa

pylint src/mcp_python_toolbox

Formato

black src/mcp_python_toolbox

Contribuyendo

Bifurcar el repositorio
Crea tu rama de funciones ( git checkout -b feature/amazing-feature )
Confirme sus cambios ( git commit -m 'Add some amazing feature' )
Empujar a la rama ( git push origin feature/amazing-feature )
Abrir una solicitud de extracción

Licencia

Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.

Expresiones de gratitud

Implementa la especificación del Protocolo de Contexto de Modelo
Desarrollado con herramientas de desarrollo de Python modernas y las mejores prácticas
Utiliza herramientas de formato (Black) y de corrección de errores (Pylint) estándar de la industria

This server cannot be installed

security - not tested

license - not found

quality - not tested

local-only server

The server can only run on the client's local machine because it depends on local resources.

Un servidor de protocolo de contexto de modelo que permite a los asistentes de IA como Claude realizar tareas de desarrollo de Python a través de operaciones de archivos, análisis de código, gestión de proyectos y ejecución segura de código.

Related Resources

Reddit Discussion about this server

Related MCP Servers

Notion MCP Server
Sjotie
A
security
F
license
A
quality
A Model Context Protocol server that connects Claude and other AI assistants to your Notion workspace, allowing AIs to interact with databases, pages, and blocks.
Last updated -
12
0
10
JavaScript
Zulip MCP Server
Monadical-SAS
-
security
A
license
-
quality
A Model Context Protocol server that enables AI assistants like Claude to interact with Zulip workspaces, supporting capabilities such as posting messages, listing channels, sending direct messages, and accessing conversation history.
Last updated -
JavaScript
Apache 2.0
Notion MCP Server
emmanuelsystems
-
security
F
license
-
quality
A Model Context Protocol server that connects AI assistants like Claude to Notion workspaces, enabling them to view, search, create, and update Notion databases, pages, and content blocks.
Last updated -
275
JavaScript
MCP Toolkit
zxfgds
-
security
F
license
-
quality
A comprehensive Model Context Protocol server implementation that enables AI assistants to interact with file systems, databases, GitHub repositories, web resources, and system tools while maintaining security and control.
Last updated -
16
TypeScript

View all related MCP servers

MCP Python Toolbox