OpenAPI转MCP生成器

# Clonar el repositorio
git clone https://github.com/enterprise/openapi-to-mcp.git
cd openapi-to-mcp-generator

# Crear entorno virtual
python -m venv .venv

# Activar entorno virtual
# Linux/Mac:
source .venv/bin/activate
# Windows:
.\.venv\Scripts\activate

# Instalar el paquete
pip install -e .

# Instalar con modo interactivo CLI (questionary)
pip install -e ".[interactive]"

# Instalar con GUI web (Flask + requests + gunicorn)
pip install -e ".[gui]"

# Instalar con IA (Ollama integration)
pip install -e ".[ai]"

# Instalar con almacenamiento MinIO
pip install -e ".[storage]"

# Instalar con PostgreSQL
pip install -e ".[postgresql]"

# Instalar con Redis (cache, token store, message broker)
pip install -e ".[redis]"

# Instalar con OAuth2
pip install -e ".[oauth2]"

# Instalar todas las características
pip install -e ".[all]"

# Instalar con herramientas de desarrollo
pip install -e ".[dev]"

openapi-to-mcp --version
# Output: openapi-to-mcp, version 1.0.0

openapi-to-mcp --help

# mi-api.yaml
openapi: "3.0.3"
info:
  title: Mi API
  version: "1.0.0"
paths:
  /users:
    get:
      summary: Listar usuarios
      responses:
        "200":
          description: Lista de usuarios

openapi-to-mcp generate mi-api.yaml --service-name mi_api

cd output/mcp_server_mi_api
pip install -r requirements.txt
python -m src.server

# Opción 1: Con archivo local
openapi-to-mcp gui mi-api.yaml

# Opción 2: Modo standalone (subir archivo o cargar desde URL)
openapi-to-mcp gui
# o
openapi-to-mcp serve

openapi-to-mcp generate <spec_path> --service-name <nombre> [opciones]

openapi-to-mcp generate ./specs/users-api.yaml \
    --service-name user_management \
    --service-prefix users \
    --base-url https://api.example.com/v2 \
    --environment production \
    --mcp-framework fastmcp \
    --output ./servers

# Incluir solo endpoints que coincidan con patrones
openapi-to-mcp generate api.yaml -n myservice \
    --include-endpoints "/v1/api/users*" \
    --include-endpoints "/v1/api/orders*"

# Excluir endpoints específicos
openapi-to-mcp generate api.yaml -n myservice \
    --exclude-endpoints "/internal/*" \
    --exclude-endpoints "*/admin/*"

# Combinar inclusión y exclusión
openapi-to-mcp generate api.yaml -n myservice \
    -i "/api/*" \
    -x "/api/internal/*" \
    -x "/api/debug/*"

# Requiere: pip install questionary
openapi-to-mcp generate api.yaml -n myservice --interactive

┌─────────────────────────────────────────────────────────────┐
│ ¿Cómo deseas seleccionar los endpoints?                    │
│                                                             │
│ > Selección manual (checkboxes)                            │
│   Por patrones (glob)                                      │
│   Por tags (grupos)                                        │
│   Todos los endpoints                                      │
└─────────────────────────────────────────────────────────────┘

# Requiere: pip install flask
openapi-to-mcp gui api.yaml

openapi-to-mcp gui <spec_path> [opciones]

# Opciones disponibles:
  --port, -p      Puerto del servidor web (default: 5000)
  --no-browser    No abrir el navegador automáticamente
  --output, -o    Directorio de salida (default: ./output)

openapi-to-mcp gui ./specs/large-api.yaml --port 8080

# Opción 1: Comando gui sin argumentos
openapi-to-mcp gui

# Opción 2: Comando serve dedicado
openapi-to-mcp serve --port 5000 --output ./output

┌─────────────────────────────────────────────────────────────────┐
│            OpenAPI to MCP Generator                              │
│                                                                  │
│     ┌─────────────────────────────────────────────────────┐     │
│     │              Carga tu especificación                 │     │
│     │                                                      │     │
│     │    [  Archivo  ]  [    URL    ]                     │     │
│     │                                                      │     │
│     │    ┌────────────────────────────────────────────┐   │     │
│     │    │                                            │   │     │
│     │    │       Arrastra tu archivo aquí             │   │     │
│     │    │                  o                         │   │     │
│     │    │      [ Seleccionar Archivo ]               │   │     │
│     │    │                                            │   │     │
│     │    │  Formatos: .yaml, .yml, .json              │   │     │
│     │    └────────────────────────────────────────────┘   │     │
│     │                                                      │     │
│     │    ─── O cargar desde URL ───                       │     │
│     │                                                      │     │
│     │    [ https://api.example.com/openapi.json ] [Cargar]│     │
│     │                                                      │     │
│     │    Ejemplos: [Petstore API] [GitHub API]            │     │
│     └─────────────────────────────────────────────────────┘     │
│                                                                  │
│     ┌─────────┐  ┌─────────┐  ┌─────────┐                       │
│     │Selección│  │ FastMCP │  │Descarga │                       │
│     │ Visual  │  │  / MCP  │  │  ZIP    │                       │
│     └─────────┘  └─────────┘  └─────────┘                       │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│  OpenAPI to MCP Generator                    API: Petstore v1.0        │
├─────────────────────────────────────────────────────────────────────────┤
│  [Vista: Lista ▼] [Buscar: ____________] [Patrón: /users/*] [Agregar]  │
├─────────────────────────────────────────────────────────────────────────┤
│  ┌─── Disponibles (15) ────┐         ┌─── Seleccionados (5) ───┐       │
│  │ □ [GET] /users          │   >>    │ ☑ [GET] /orders         │       │
│  │ □ [POST] /users         │         │ ☑ [POST] /orders        │       │
│  │ □ [GET] /users/{id}     │   <<    │ ☑ [GET] /orders/{id}    │       │
│  │ □ [PUT] /users/{id}     │         │ ☑ [PUT] /orders/{id}    │       │
│  │ □ [DELETE] /users/{id}  │         │ ☑ [DELETE] /orders/{id} │       │
│  └─────────────────────────┘         └─────────────────────────┘       │
│                                                                         │
│  ┌─ Configuración ─────────────────────────────────────────────────┐   │
│  │ Nombre: [myservice    ] Prefijo: [myservice] URL: [          ]  │   │
│  │ Framework: [FastMCP ▼]  Ambiente: [Production ▼]                │   │
│  │ [✓] Descargar como ZIP                                          │   │
│  └─────────────────────────────────────────────────────────────────┘   │
│                                                                         │
│  [Cancelar]                                    [Generar Servidor MCP]   │
└─────────────────────────────────────────────────────────────────────────┘

# Construir la imagen
docker build -t openapi-to-mcp .

# Ejecutar el contenedor
docker run -p 5000:5000 openapi-to-mcp

# Iniciar el servicio
docker-compose up -d

# Ver logs
docker-compose logs -f

# Detener
docker-compose down

version: '3.8'

services:
  openapi-to-mcp:
    build: .
    ports:
      - "5000:5000"
    environment:
      - PORT=5000
      - WORKERS=2
      - THREADS=4
    volumes:
      - mcp-output:/app/output
    restart: unless-stopped

volumes:
  mcp-output:

# Levantar todos los servicios de desarrollo
docker-compose -f docker-compose.dev.yml up -d

# Verificar que todo esté corriendo
docker-compose -f docker-compose.dev.yml ps

# Ver logs de un servicio específico
docker-compose -f docker-compose.dev.yml logs -f ollama

# .env
DATABASE_TYPE=postgresql
DB_HOST=localhost
DB_PORT=5432
DB_NAME=openapi_mcp
DB_USER=openapi_mcp
DB_PASSWORD=development

ENABLE_AI=true
ENABLE_STORAGE=true

REDIS_URL=redis://localhost:6379/0
MINIO_ENDPOINT=localhost:9000
OLLAMA_HOST=localhost

server {
    listen 80;
    server_name openapi-mcp.example.com;

    location / {
        proxy_pass http://localhost:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

openapi-to-mcp generate api.yaml -n myservice --mcp-framework fastmcp

from fastmcp import FastMCP

mcp = FastMCP("myservice")

@mcp.tool(description="Listar usuarios")
async def myservice_list_users(page: int = 1, limit: int = 10) -> str:
    response = await http_client.request(
        method="GET",
        path="/users",
        params={"page": page, "limit": limit}
    )
    return json.dumps(response)

if __name__ == "__main__":
    mcp.run()

openapi-to-mcp generate api.yaml -n myservice --mcp-framework mcp

# config/config.yaml
service_name: user_management
base_url: https://api.enterprise.com/v2
timeout: 30
environment: production
log_level: INFO

retry:
  max_retries: 3
  backoff_factor: 0.5
  retry_statuses:
    - 429
    - 500
    - 502
    - 503
    - 504

auth:
  type: bearer  # none, api_key, bearer, basic, oauth2

# .env
BASE_URL=https://api.enterprise.com/v2
TIMEOUT=30
LOG_LEVEL=INFO
ENVIRONMENT=production

# Autenticación
API_KEY=your_api_key
AUTH_TOKEN=your_bearer_token

# batch-config.yaml
output_dir: ./output

services:
  - name: users
    spec: ./specs/users-api.yaml
    base_url: https://users.api.com

  - name: orders
    spec: ./specs/orders-api.yaml
    base_url: https://orders.api.com

openapi-to-mcp batch ./batch-config.yaml

{
  "mcpServers": {
    "user_management": {
      "command": "python",
      "args": ["-m", "src.server"],
      "cwd": "/path/to/mcp_server_user_management",
      "env": {
        "BASE_URL": "https://api.enterprise.com/v2",
        "AUTH_TOKEN": "your_token"
      }
    }
  }
}

cp .env.example .env

ENABLE_AI=true       # Integración Ollama (análisis IA)
ENABLE_STORAGE=true  # MinIO (almacenamiento S3)
ENABLE_OAUTH2=true   # OAuth2 token management
ENABLE_AGENTS=true   # Multi-agent architecture (futuro)

# Inicia PostgreSQL, Redis, MinIO y Ollama
docker-compose -f docker-compose.dev.yml up -d

# Verificar estado
curl http://localhost:5000/api/features

{
  "ai": {"enabled": true, "ollama_url": "http://localhost:11434"},
  "storage": {"enabled": true, "endpoint": "localhost:9000"},
  "oauth2": {"enabled": false, "configured": false},
  "agents": {"enabled": false},
  "database": {"type": "sqlite"}
}

curl -X POST http://localhost:5000/api/ai/analyze-spec \
  -H "Content-Type: application/json" \
  -d '{"spec_content": "openapi: 3.0.3\ninfo:\n  title: My API..."}'

{
  "analysis": {
    "quality_score": 78,
    "summary": "REST API with user management endpoints",
    "total_endpoints": 12,
    "issues": [
      {"severity": "warning", "path": "/users", "message": "Missing pagination"}
    ],
    "mcp_recommendations": {
      "priority_endpoints": ["/users", "/orders"],
      "suggested_tools": ["list_users", "create_order"]
    }
  },
  "model": "llama3.2:3b",
  "tokens_used": 1250,
  "duration_ms": 3400
}

OLLAMA_HOST=localhost
OLLAMA_PORT=11434
OLLAMA_MODEL_SPEC_ANALYSIS=llama3.2:3b
OLLAMA_MODEL_CODE_GENERATION=codellama:7b
OLLAMA_MODEL_DOCUMENTATION=llama3.2:3b
OLLAMA_MODEL_VALIDATION=llama3.2:1b
OLLAMA_RATE_LIMIT_RPM=30

curl -X POST http://localhost:5000/api/storage/upload \
  -F "file=@mi-api.yaml" \
  -F "bucket=openapi-specs" \
  -F "key=project1/v1/api.yaml"

curl http://localhost:5000/api/storage/objects/openapi-specs?prefix=project1/

MINIO_ENDPOINT=localhost:9000
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin
MINIO_SECURE=false

1. Registrar proveedor → GET /api/auth/oauth2/authorize/{provider}
2. Usuario autoriza     → Redirect a authorization_url
3. Callback con code    → GET /api/auth/oauth2/callback?code=...
4. Token almacenado     → Auto-refresh antes de expiración
5. MCP Context          → GET /api/auth/oauth2/mcp-context/{provider}/{user}

OAUTH2_ISSUER=https://your-domain.auth0.com
OAUTH2_CLIENT_ID=your-client-id
OAUTH2_CLIENT_SECRET=your-client-secret
OAUTH2_REDIRECT_URI=http://localhost:5000/api/auth/oauth2/callback
OAUTH2_TOKEN_STORE=redis
OAUTH2_REFRESH_BUFFER=300

# Obtener logs filtrados por severidad y rango de fechas
curl "http://localhost:5000/api/audit/logs?severity=HIGH&days=7&limit=50"

# Exportar logs en CSV
curl "http://localhost:5000/api/audit/export?format=csv&start_date=2025-01-01"

# Resumen de auditoría (estadísticas)
curl "http://localhost:5000/api/audit/summary?workspace_id=1"

{
  "total_events": 1523,
  "by_severity": {"LOW": 890, "MEDIUM": 412, "HIGH": 198, "CRITICAL": 23},
  "top_actions": [
    {"action": "SPEC_UPLOADED", "count": 342},
    {"action": "MCP_GENERATED", "count": 289}
  ],
  "active_users": 12
}

# Encriptar una spec
curl -X POST http://localhost:5000/api/encryption/encrypt \
  -H "Content-Type: application/json" \
  -d '{"spec_id": 1, "password": "mi-clave-segura"}'

# Desencriptar
curl -X POST http://localhost:5000/api/encryption/decrypt \
  -H "Content-Type: application/json" \
  -d '{"spec_id": 1, "password": "mi-clave-segura"}'

# Rotar clave
curl -X POST http://localhost:5000/api/encryption/rotate \
  -H "Content-Type: application/json" \
  -d '{"spec_id": 1, "old_password": "clave-vieja", "new_password": "clave-nueva"}'

# Crear regla de alerta
curl -X POST http://localhost:5000/api/alerts/rules \
  -H "Content-Type: application/json" \
  -d '{
    "alert_type": "FAILED_LOGINS",
    "severity": "HIGH",
    "threshold": 5,
    "period_minutes": 15,
    "channels": ["email", "webhook"],
    "cooldown_minutes": 60,
    "workspace_id": 1
  }'

# Listar alertas activas
curl "http://localhost:5000/api/alerts?status=ACTIVE&severity=HIGH"

# Reconocer una alerta
curl -X POST http://localhost:5000/api/alerts/42/acknowledge

# Resolver una alerta
curl -X POST http://localhost:5000/api/alerts/42/resolve

# Generar reporte manualmente
curl -X POST http://localhost:5000/api/reports/generate \
  -H "Content-Type: application/json" \
  -d '{"report_type": "SECURITY_AUDIT", "period_days": 30, "workspace_id": 1}'

# Programar reporte automático
curl -X POST http://localhost:5000/api/reports/scheduled \
  -H "Content-Type: application/json" \
  -d '{
    "report_type": "USAGE_SUMMARY",
    "format": "HTML",
    "schedule": "WEEKLY",
    "workspace_id": 1,
    "delivery_email": "admin@empresa.com"
  }'

# Exportar reporte en formato específico
curl "http://localhost:5000/api/reports/generated/15/export?format=csv"

# Listar reportes generados
curl "http://localhost:5000/api/reports/generated?workspace_id=1&limit=20"

# Dashboard completo
curl http://localhost:5000/api/metrics/dashboard

# Métricas de seguridad
curl http://localhost:5000/api/metrics/security

{
  "failed_logins_24h": 3,
  "successful_logins_24h": 47,
  "high_severity_events": 5,
  "critical_events": 0,
  "suspicious_ips": ["192.168.1.100"],
  "by_severity": {"LOW": 120, "MEDIUM": 34, "HIGH": 5, "CRITICAL": 0}
}

# Configurar política de retención
curl -X POST http://localhost:5000/api/retention/policies \
  -H "Content-Type: application/json" \
  -d '{
    "data_type": "AUDIT_LOGS",
    "retention_days": 180,
    "action": "ARCHIVE",
    "workspace_id": 1
  }'

# Ejecutar cleanup (dry-run primero)
curl -X POST http://localhost:5000/api/retention/execute \
  -H "Content-Type: application/json" \
  -d '{"workspace_id": 1, "dry_run": true}'

# Ver estadísticas de retención
curl "http://localhost:5000/api/retention/stats?workspace_id=1"

# Historial de ejecuciones
curl "http://localhost:5000/api/retention/history?workspace_id=1"

DATABASE_TYPE=sqlite
# Usa archivo local en output/instance/app.db

DATABASE_TYPE=postgresql
DB_HOST=localhost
DB_PORT=5432
DB_NAME=openapi_mcp
DB_USER=postgres
DB_PASSWORD=your-password
# O usando URL directa:
# DATABASE_URL=postgresql://user:pass@localhost:5432/openapi_mcp

DATABASE_TYPE=mongodb
DATABASE_URL=mongodb://user:pass@localhost:27017/openapi_mcp

# Verificar salud de la base de datos
curl http://localhost:5000/api/health

# Información detallada
curl http://localhost:5000/api/database/info

{
  "type": "postgresql",
  "url_masked": "postgresql://***@localhost:5432/openapi_mcp",
  "healthy": true,
  "server_version": "16.1",
  "database_size": "24 MB"
}

┌─────────────────────────────────────────────────────────────────┐
│                    OpenAPI Specification                         │
│                    (YAML/JSON 3.0/3.1)                          │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                      OpenAPI Parser                              │
│  - Validación de spec                                           │
│  - Resolución de $refs                                          │
│  - Extracción de paths, schemas, security                       │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Endpoint Selector                             │
│  - Filtrado por patrones CLI                                    │
│  - Selección interactiva                                        │
│  - Selección via GUI web                                        │
│  - Carga desde archivo o URL                                    │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
              ┌───────────────┴───────────────┐
              │                               │
              ▼                               ▼
┌─────────────────────────┐     ┌─────────────────────────┐
│    Tool Transformer     │     │  Resource Transformer   │
└─────────────────────────┘     └─────────────────────────┘
              │                               │
              └───────────────┬───────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    MCP Server Generator                          │
│  - Genera código server.py (FastMCP o MCP)                      │
│  - Crea http_client.py, auth.py, config.py                      │
│  - Genera requirements.txt, Dockerfile, README                  │
│  - Opcionalmente crea ZIP para descarga                         │
└─────────────────────────────────────────────────────────────────┘

openapi-to-mcp-generator/
├── src/
│   └── openapi_to_mcp/
│       ├── models.py              # Modelos de datos
│       ├── cli.py                 # Interfaz de comandos
│       ├── endpoint_selector.py   # Selector de endpoints
│       ├── config/                # ⚙️ Configuración centralizada
│       │   ├── __init__.py
│       │   └── settings.py        # Pydantic Settings (Ollama, MinIO, OAuth2)
│       ├── ai/                    # 🤖 Integración IA
│       │   ├── __init__.py
│       │   └── ollama_client.py   # Cliente Ollama (6 tareas IA)
│       ├── auth/                  # 🔐 Autenticación
│       │   ├── __init__.py
│       │   └── oauth2.py          # OAuth2 Manager + Token Stores
│       ├── storage/               # 📦 Almacenamiento
│       │   ├── __init__.py
│       │   └── adapters/
│       │       ├── base.py        # Interfaz StorageAdapter
│       │       ├── local_adapter.py
│       │       └── minio_adapter.py
│       ├── parsers/
│       │   └── openapi_parser.py
│       ├── transformers/
│       │   ├── tool_transformer.py
│       │   └── resource_transformer.py
│       ├── generators/
│       │   └── server_generator.py
│       └── gui/                   # Interfaz web
│           ├── web_app.py         # 80+ API endpoints
│           ├── db_config.py       # Multi-database config
│           ├── database.py        # SQLAlchemy models
│           ├── audit.py           # Audit logging
│           ├── encryption.py      # AES-256 encryption
│           ├── retention.py       # Data retention
│           ├── metrics.py         # Usage metrics
│           ├── alerts.py          # Configurable alerts
│           ├── reports.py         # Automatic reports
│           ├── templates/
│           │   ├── index.html     # Selector de endpoints
│           │   ├── upload.html    # Página de carga
│           │   ├── admin.html     # Dashboard admin
│           │   └── login.html     # Autenticación
│           └── static/
│               ├── style.css
│               └── app.js
├── .env.example                   # Variables de entorno
├── Dockerfile
├── docker-compose.yml             # Producción
├── docker-compose.dev.yml         # Desarrollo (PostgreSQL, Redis, MinIO, Ollama)
├── docker-entrypoint.sh
├── examples/
├── tests/
└── pyproject.toml

from openapi_to_mcp import (
    OpenAPIParser,
    ToolTransformer,
    ResourceTransformer,
    MCPServerGenerator,
    MCPServerConfig,
    MCPFramework,
    EndpointFilter,
)

# 1. Parsear especificación
parser = OpenAPIParser()
spec = parser.parse("api.yaml")

# 2. Filtrar endpoints
endpoint_filter = EndpointFilter(
    include_patterns=["/users/*", "/orders/*"],
    exclude_patterns=["/internal/*"]
)

# 3. Transformar y generar
transformer = ToolTransformer(service_prefix="myapi")
tools = transformer.transform(spec, endpoint_filter=endpoint_filter)

config = MCPServerConfig(
    service_name="my_service",
    mcp_framework=MCPFramework.FASTMCP,
)

generator = MCPServerGenerator(output_dir="./output")
result = generator.generate(spec, tools, resources, config)

# Validar especificación OpenAPI
openapi-to-mcp validate ./api.yaml

# Vista previa de tools y resources
openapi-to-mcp preview ./api.yaml --service-prefix myapi

# Modo verbose para debugging
openapi-to-mcp -v generate ./api.yaml -n myservice

# Iniciar servidor web standalone
openapi-to-mcp serve --port 8080

┌─────────────────────────────────────────────────────────────────┐
│  📋 Petstore API - Historial de Versiones                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ●───●───●───●───◉  (Timeline)                                  │
│  v1  v2  v3  v4  v5                                             │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ v5 (actual) - 2024-01-15 14:32                          │   │
│  │ ├─ 🔧 MCP generado: 2024-01-15 14:35                    │   │
│  │ ├─ Endpoints: 24 (+3 desde v4)                          │   │
│  │ └─ Nota: "Agregados endpoints de autenticación OAuth"   │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │ v4 - 2024-01-10 09:15                                   │   │
│  │ ├─ 🔧 MCP generado: 2024-01-10 09:20                    │   │
│  │ ├─ 🔧 MCP generado: 2024-01-12 16:45                    │   │
│  │ ├─ Endpoints: 21                                        │   │
│  │ └─ Nota: "Refactoring de rutas de usuarios"             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  [Ver Diff v4 ↔ v5]  [Restaurar v4]  [Exportar Historial]      │
└─────────────────────────────────────────────────────────────────┘

# Configuración directa en formato YAML
service_name: "petstore_api"
mcp_framework: "fastmcp"
output_format: "python"
service_prefix: "petstore"
generate_resources: true
auth_config:
  type: "bearer"
  token_env: "PETSTORE_API_KEY"
endpoint_filters:
  include: ["/pets/*", "/store/*"]
  exclude: ["/internal/*"]

┌─────────────────────────────────────────────────────────────────┐
│  ⚙️ Configuración MCP - Petstore API                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Información General                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Nombre del servicio: [petstore_api_________]            │   │
│  │ Prefijo:             [petstore_____________]            │   │
│  │ Framework:           [FastMCP ▼]                        │   │
│  │ Formato salida:      ○ Python  ○ TypeScript (futuro)    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Autenticación                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Tipo:     [Bearer Token ▼]                              │   │
│  │ Variable: [PETSTORE_API_KEY___]                         │   │
│  │ □ Requerido para todos los endpoints                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Generación                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ ☑ Generar Resources                                     │   │
│  │ ☑ Incluir validación de parámetros                      │   │
│  │ ☑ Generar documentación inline                          │   │
│  │ □ Modo estricto (fallar en warnings)                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  [Modo Editor YAML]  [Guardar Config]  [Restaurar Defaults]    │
└─────────────────────────────────────────────────────────────────┘