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

Related MCP server: Hass-MCP

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

1. Clonar el repositorio:

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

2. Crear y activar un entorno virtual:

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

3. 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:

1. Instale y configure MCP Python Toolbox como se describe arriba

2. 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": ""
  }
}

3. Personaliza las rutas para que coincidan con tu entorno.

4. Claude Desktop iniciará automáticamente el servidor MCP cuando sea necesario

5. 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

1. Bifurcar el repositorio

2. Crea tu rama de funciones ( git checkout -b feature/amazing-feature )

3. Confirme sus cambios ( git commit -m 'Add some amazing feature' )

4. Empujar a la rama ( git push origin feature/amazing-feature )

5. 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