Servicio MCP de migraciones de Django

Un servicio de Protocolo de Contexto de Modelo (MCP) para gestionar migraciones de Django en entornos distribuidos. Este servicio encapsula los comandos de migración de Django y los expone como puntos finales de MCP, lo que facilita la gestión de migraciones entre múltiples servicios y la integración con pipelines de CI/CD.

Características

Comprobar el estado de la migración (equivalente a showmigrations )
Crear nuevas migraciones con validación (equivalente a makemigrations )
Aplicar migraciones con comprobaciones de seguridad (equivalente a migrate )
Comprobaciones adicionales de validación y seguridad:
- Verificación del orden de migración secuencial
- Detección de conflictos
- Validación de dependencia
- Análisis de seguridad de las operaciones migratorias

Instalación

Desarrollo local

Clonar el repositorio:

git clone https://github.com/mrrobotke/django-migrations-mcp.git
cd django-migrations-mcp

Instalar dependencias:

pip install -r requirements.txt

Configuración

Establezca las siguientes variables de entorno:

export DJANGO_SETTINGS_MODULE="your_project.settings"
export MCP_SERVICE_PORT=8000  # Optional, defaults to 8000

Uso

Ejecución del servicio

Directamente con Python:

python -m migrations_mcp.service

Usando Docker:

docker build -t django-migrations-mcp .
docker run -e DJANGO_SETTINGS_MODULE=your_project.settings \
          -v /path/to/your/django/project:/app/project \
          -p 8000:8000 \
          django-migrations-mcp

Puntos finales de MCP

Mostrar migraciones:

from mcp import MCPClient

client = MCPClient()
migrations = await client.call("show_migrations")

Realizar migraciones:

result = await client.call("make_migrations", {
    "app_labels": ["myapp"],  # Optional
    "dry_run": True  # Optional
})

Aplicar Migraciones:

result = await client.call("migrate", {
    "app_label": "myapp",  # Optional
    "migration_name": "0001",  # Optional
    "fake": False,  # Optional
    "plan": True  # Optional
})

Integración CI/CD

Ejemplo de flujo de trabajo de Acciones de GitHub:

name: Django Migrations Check

on:
  pull_request:
    paths:
      - '*/migrations/*.py'
      - '*/models.py'

jobs:
  check-migrations:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.11'
    
    - name: Install dependencies
      run: |
        pip install -r requirements.txt
    
    - name: Start MCP service
      run: |
        python -m migrations_mcp.service &
    
    - name: Check migrations
      run: |
        python ci/check_migrations.py

Ejemplo de script check_migrations.py:

import asyncio
from mcp import MCPClient

async def check_migrations():
    client = MCPClient()
    
    # Check current status
    migrations = await client.call("show_migrations")
    
    # Try making migrations
    result = await client.call("make_migrations", {"dry_run": True})
    if not result.success:
        print(f"Error: {result.message}")
        exit(1)
    
    print("Migration check passed!")

if __name__ == "__main__":
    asyncio.run(check_migrations())

Desarrollo

Ejecución de pruebas

pytest migrations_mcp/tests/

Estilo de código

El proyecto sigue las directrices PEP 8. Formatee su código con:

black migrations_mcp/
isort migrations_mcp/

Licencia

Licencia MIT. Consulte el archivo de LICENCIA para obtener más detalles.

Contribuyendo

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

Uso de Docker

El proyecto incluye un archivo docker-commands.json que proporciona comandos estructurados para diferentes escenarios de implementación. Puedes usarlos directamente o analizarlos en tus scripts.

Configuraciones de Docker disponibles

Servidor MCP de Redis

# Run Redis MCP server
docker run -i --rm mcp/redis redis://host.docker.internal:6379

Servidor MCP de migraciones de Django

# Basic setup
docker run -d \
  --name django-migrations-mcp \
  -e DJANGO_SETTINGS_MODULE=your_project.settings \
  -e MCP_SERVICE_PORT=8000 \
  -v /path/to/your/django/project:/app/project \
  -p 8000:8000 \
  django-migrations-mcp

# With Redis integration
docker run -d \
  --name django-migrations-mcp \
  -e DJANGO_SETTINGS_MODULE=your_project.settings \
  -e MCP_SERVICE_PORT=8000 \
  -e REDIS_URL=redis://host.docker.internal:6379 \
  -v /path/to/your/django/project:/app/project \
  -p 8000:8000 \
  --network host \
  django-migrations-mcp

Entorno de desarrollo

# Using docker-compose
docker-compose up -d --build

Entorno de prueba

# Run tests in container
docker run --rm \
  -e DJANGO_SETTINGS_MODULE=your_project.settings \
  -e PYTHONPATH=/app \
  -v ${PWD}:/app \
  django-migrations-mcp \
  pytest

Entorno de producción

# Production setup with health check
docker run -d \
  --name django-migrations-mcp \
  -e DJANGO_SETTINGS_MODULE=your_project.settings \
  -e MCP_SERVICE_PORT=8000 \
  -e REDIS_URL=redis://your-redis-host:6379 \
  -v /path/to/your/django/project:/app/project \
  -p 8000:8000 \
  --restart unless-stopped \
  --network your-network \
  django-migrations-mcp

Uso de los comandos mediante programación

Puede analizar y utilizar los comandos mediante programación:

import json
import subprocess

# Load commands
with open('docker-commands.json') as f:
    commands = json.load(f)

# Run Redis MCP server
redis_config = commands['mcpServers']['redis']
subprocess.run([redis_config['command']] + redis_config['args'])

# Run Django Migrations MCP server
django_config = commands['mcpServers']['djangoMigrations']
subprocess.run([django_config['command']] + django_config['args'])

Configuración de red

Red de Desarrollo

docker network create mcp-dev-network

Red de producción

docker network create --driver overlay --attachable mcp-prod-network

Uso de herramientas MCP

El servicio expone varios puntos finales a los que se puede acceder a través de curl o cualquier cliente HTTP:

Mostrar migraciones

curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{"method": "show_migrations"}'

Realizar migraciones

curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{"method": "make_migrations", "params": {"apps": ["your_app"]}}'

Aplicar migraciones

curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{"method": "migrate", "params": {"app": "your_app"}}'

This server cannot be installed

security - not tested

license - not found

quality - not tested

How are these scores calculated?

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

Un servicio de Protocolo de Contexto de Modelo que envuelve los comandos de migración de Django como puntos finales de MCP, lo que facilita la administración de migraciones entre múltiples servicios y la integración con canales de CI/CD.

Related Resources

Reddit Discussion about this server

Related MCP Servers

MCP Create Server
tesla0225
A
security
A
license
A
quality
A dynamic service that creates and manages Model Context Protocol (MCP) servers, allowing users to spawn, customize, and control multiple MCP servers as child processes.
Last updated -
5
0
84
TypeScript
MIT License
mcp-dbs
cuongtl1992
-
security
A
license
-
quality
A Model Context Protocol (MCP) implementation for connecting to and working with various database systems.
Last updated -
17
18
TypeScript
MIT License
AgentModeofficial
agentmode
A
security
F
license
A
quality
An all-in-one Model Context Protocol (MCP) server that connects your coding AI to numerous databases, data warehouses, data pipelines, and cloud services, streamlining development workflow through seamless integrations.
Last updated -
2
Python
MongoDB MCP Server
TeiNam
-
security
A
license
-
quality
A powerful Model Context Protocol (MCP) server implementation that provides standardized interaction with MongoDB databases, supporting complete CRUD operations, async patterns, and real-time updates via SSE.
Last updated -
Python
MIT License

View all related MCP servers

Django Migrations MCP Service