FluxMCP

Name: FluxMCP
Author: AceDataCloud

PyPI version PyPI downloads License: MIT MCP Python 3.10+

Un servidor de Protocolo de Contexto de Modelo (MCP) para la generación y edición de imágenes mediante IA utilizando Flux a través de la plataforma AceDataCloud.

Genera y edita impresionantes imágenes mediante IA con modelos Flux (flux-dev, flux-pro, flux-kontext) directamente desde Claude, Cursor o cualquier cliente compatible con MCP.

Características

Generación de imágenes - Genera imágenes a partir de prompts de texto con 6 modelos Flux
Edición de imágenes - Edita imágenes existentes con modelos Flux Kontext conscientes del contexto
Gestión de tareas - Realiza un seguimiento de las tareas de generación asíncronas y consultas de estado por lotes
Guía de modelos - Guía integrada para la selección de modelos y la redacción de prompts
Transporte dual - Modos stdio (local) y HTTP (remoto/nube)
Listo para Docker - Contenerizado con manifiestos de despliegue para K8s
Seguro - Autenticación mediante token Bearer con aislamiento por solicitud en modo HTTP

Referencia de herramientas

Herramienta	Descripción
`flux_generate_image`	Genera imágenes de IA a partir de un prompt de texto usando Flux.
`flux_edit_image`	Edita una imagen existente usando Flux con un prompt de texto.
`flux_list_models`	Lista todos los modelos Flux disponibles y sus capacidades.
`flux_list_actions`	Lista todas las herramientas Flux disponibles y sus casos de uso.
`flux_get_task`	Consulta el estado y el resultado de una tarea de generación de imágenes de Flux.
`flux_get_tasks_batch`	Consulta múltiples tareas de generación de imágenes de Flux a la vez.

Inicio rápido

1. Obtén tu token de API

Regístrate en la Plataforma AceDataCloud
Ve a la página de documentación de la API
Haz clic en "Acquire" para obtener tu token de API
Copia el token para usarlo a continuación

2. Usa el servidor alojado (Recomendado)

AceDataCloud aloja un servidor MCP gestionado — no se requiere instalación local.

Endpoint: https://flux.mcp.acedata.cloud/mcp

Todas las solicitudes requieren un token Bearer. Usa el token de API del Paso 1.

Claude.ai

Conéctate directamente en Claude.ai con OAuth — no se necesita token de API:

Ve a Settings → Integrations → Add More en Claude.ai
Introduce la URL del servidor: https://flux.mcp.acedata.cloud/mcp
Completa el flujo de inicio de sesión OAuth
Empieza a usar las herramientas en tu conversación

Claude Desktop

Añádelo a tu configuración (~/Library/Application Support/Claude/claude_desktop_config.json en macOS):

{
  "mcpServers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Cursor / Windsurf

Añádelo a tu configuración MCP (.cursor/mcp.json o .windsurf/mcp.json):

{
  "mcpServers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

VS Code (Copilot)

Añádelo a tu configuración MCP de VS Code (.vscode/mcp.json):

{
  "servers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

O instala la extensión Ace Data Cloud MCP para VS Code, que agrupa los 15 servidores MCP con una configuración de un solo clic.

IDEs de JetBrains

Ve a Settings → Tools → AI Assistant → Model Context Protocol (MCP)
Haz clic en Add → HTTP
Pega:

{
  "mcpServers": {
    "flux": {
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Claude Code

Claude Code admite servidores MCP de forma nativa:

claude mcp add flux --transport http https://flux.mcp.acedata.cloud/mcp \
  -h "Authorization: Bearer YOUR_API_TOKEN"

O añádelo al .mcp.json de tu proyecto:

{
  "mcpServers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Cline

Añádelo a la configuración MCP de Cline (.cline/mcp_settings.json):

{
  "mcpServers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Amazon Q Developer

Añádelo a tu configuración MCP:

{
  "mcpServers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Roo Code

Añádelo a la configuración MCP de Roo Code:

{
  "mcpServers": {
    "flux": {
      "type": "streamable-http",
      "url": "https://flux.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Continue.dev

Añádelo a .continue/config.yaml:

mcpServers:
  - name: flux
    type: streamable-http
    url: https://flux.mcp.acedata.cloud/mcp
    headers:
      Authorization: "Bearer YOUR_API_TOKEN"

Zed

Añádelo a la configuración de Zed (~/.config/zed/settings.json):

{
  "language_models": {
    "mcp_servers": {
      "flux": {
        "url": "https://flux.mcp.acedata.cloud/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_API_TOKEN"
        }
      }
    }
  }
}

Prueba con cURL

# Health check (no auth required)
curl https://flux.mcp.acedata.cloud/health

# MCP initialize
curl -X POST https://flux.mcp.acedata.cloud/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

3. O ejecútalo localmente (Alternativa)

Si prefieres ejecutar el servidor en tu propia máquina:

# Install from PyPI
pip install mcp-flux-pro
# or
uvx mcp-flux-pro

# Set your API token
export ACEDATACLOUD_API_TOKEN="your_token_here"

# Run (stdio mode for Claude Desktop / local clients)
mcp-flux-pro

# Run (HTTP mode for remote access)
mcp-flux-pro --transport http --port 8000

Claude Desktop (Local)

{
  "mcpServers": {
    "flux": {
      "command": "uvx",
      "args": ["mcp-flux-pro"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your_token_here"
      }
    }
  }
}

Docker (Autoalojamiento)

docker pull ghcr.io/acedatacloud/mcp-flux-pro:latest
docker run -p 8000:8000 ghcr.io/acedatacloud/mcp-flux-pro:latest

Los clientes se conectan con su propio token Bearer — el servidor extrae el token del encabezado Authorization de cada solicitud.

Herramientas disponibles

Herramienta	Descripción
`flux_generate_image`	Genera imágenes a partir de prompts de texto con selección de modelo
`flux_edit_image`	Edita imágenes existentes con instrucciones de texto
`flux_get_task`	Consulta el estado de una tarea de generación individual
`flux_get_tasks_batch`	Consulta múltiples estados de tareas a la vez
`flux_list_models`	Lista todos los modelos Flux disponibles y sus capacidades
`flux_list_actions`	Muestra todas las herramientas y ejemplos de flujo de trabajo

Prompts disponibles

Prompt	Descripción
`flux_image_generation_guide`	Guía para elegir la herramienta y el modelo adecuados
`flux_prompt_writing_guide`	Mejores prácticas para escribir prompts efectivos
`flux_workflow_examples`	Patrones de flujo de trabajo comunes y ejemplos

Modelos compatibles

Modelo	Calidad	Velocidad	Formato de tamaño	Ideal para
`flux-dev`	Buena	Rápida	Píxeles (256-1440px)	Prototipado rápido
`flux-pro`	Alta	Media	Píxeles (256-1440px)	Uso en producción
`flux-pro-1.1`	Alta	Media	Píxeles (256-1440px)	Mejor seguimiento de prompts
`flux-pro-1.1-ultra`	Máxima	Más lenta	Relaciones de aspecto	Calidad máxima
`flux-kontext-pro`	Alta	Media	Relaciones de aspecto	Edición de imágenes
`flux-kontext-max`	Máxima	Más lenta	Relaciones de aspecto	Edición compleja

Ejemplos de uso

Generar una imagen

"Generate a photorealistic mountain landscape at golden hour"
→ flux_generate_image(prompt="...", model="flux-pro-1.1-ultra", size="16:9")

Editar una imagen

"Add sunglasses to the person in this photo"
→ flux_edit_image(prompt="Add sunglasses", image_url="https://...", model="flux-kontext-pro")

Comprobar el estado de la tarea

"What's the status of my generation?"
→ flux_get_task(task_id="...")

Variables de entorno

Variable	Requerido	Predeterminado	Descripción
`ACEDATACLOUD_API_TOKEN`	Sí (stdio)	—	Token de API de AceDataCloud
`ACEDATACLOUD_API_BASE_URL`	No	`https://api.acedata.cloud`	URL base de la API
`ACEDATACLOUD_OAUTH_CLIENT_ID`	No	—	ID de cliente OAuth (modo alojado)
`ACEDATACLOUD_PLATFORM_BASE_URL`	No	`https://platform.acedata.cloud`	URL base de la plataforma
`FLUX_REQUEST_TIMEOUT`	No	`1800`	Tiempo de espera de solicitud en segundos
`MCP_SERVER_NAME`	No	`flux`	Nombre del servidor MCP
`LOG_LEVEL`	No	`INFO`	Nivel de registro

Desarrollo

Configuración

git clone https://github.com/AceDataCloud/FluxMCP.git
cd FluxMCP
pip install -e ".[all]"
cp .env.example .env
# Edit .env with your API token

Lint y formato

ruff check .
ruff format .
mypy core tools main.py

Prueba

# Unit tests
pytest --cov=core --cov=tools

# Skip integration tests
pytest -m "not integration"

# With coverage report
pytest --cov=core --cov=tools --cov-report=html

Git Hooks

git config core.hooksPath .githooks

Referencia de la API

Este servidor MCP utiliza la API de Flux de AceDataCloud:

POST /flux/images — Generar o editar imágenes
POST /flux/tasks — Consultar el estado de la tarea (individual o por lotes)

Documentación completa de la API: platform.acedata.cloud

Licencia

Licencia MIT — ver LICENSE para más detalles.