Kie AI MCP: deja que tu asistente de IA genere imágenes y las guarde en disco

Kie AI MCP — generación de imágenes desde cualquier agente compatible con MCP

El último hueco para darle a un asistente de IA manos de verdad es dejar que cree imágenes, no solo que las describa. Hay muchas APIs de generación, pero todas vienen con el mismo baile: enviar una tarea, sondear el estado, esperar, y luego descargar el archivo antes de que expire. Tedioso de conectar a mano, y mal encaje para un turno de chat. Así que construí kie-ai-mcp: un servidor Model Context Protocol, escrito en Go, que hace de puente con la API de generación de imágenes de Kie AI y se encarga de todo ese ciclo por ti.

Crea tareas, las sondea hasta su finalización, y guarda la imagen resultante directamente en disco — así tu agente puede pasar de un prompt a un archivo en una sola llamada.

Qué hace

El servidor colapsa el ciclo de vida crear → sondear → descargar en herramientas que un agente puede manejar desde lenguaje natural:

Crea tareas de generación de imágenes vía Kie AI
Sondea el estado de la tarea hasta su finalización — o devuelve un task id para flujos asíncronos
Descarga la imagen resultante y la escribe en disco
Soporta generación por lotes en paralelo con un estilo y un prompt explícitos por elemento

Ese último punto es el que más aprovecho. Pedir diez variaciones de un concepto solía significar diez idas y vueltas; aquí es una sola llamada por lotes con max_workers y salidas y errores por elemento.

La caja de herramientas

Cinco herramientas MCP enfocadas cubren tanto los flujos de disparar-y-olvidar como los de esperar-el-resultado:

Herramienta	Qué hace
`describe_imager_interface`	Devuelve los contratos de las herramientas e información del entorno — llámala primero para ver qué está configurado.
`create_visual_task`	Crea una tarea de generación y devuelve un `task_id`.
`get_visual_task`	Obtiene el estado de una tarea por `task_id`.
`generate_visual`	Crea una tarea y espera el resultado de la imagen.
`generate_visual_batch`	Ejecuta múltiples generaciones en paralelo (`items[]`, `default_style`, `max_workers`, salidas/errores por elemento).

Usa generate_visual cuando solo quieras la imagen. Baja a create_visual_task + get_visual_task cuando prefieras lanzar una tarea larga y revisar más tarde.

Configuración

Compilación

El servidor es un único binario de Go:

make build

Configura tu clave de API

Pasa la clave a través del bloque env del host MCP — la clave vive fuera del repositorio y nunca aparece en los mensajes de las herramientas ni en los logs.

{
  "kie-ai-mcp": {
    "command": "/path/to/kie-ai-mcp",
    "env": {
      "KIE_AI_API_KEY": "your-key-here"
    }
  }
}

Esa es la única variable obligatoria. Todo lo demás tiene un valor por defecto sensato:

Variable	Obligatoria	Por defecto	Descripción
`KIE_AI_API_KEY`	sí	—	Tu clave de API de Kie AI
`KIE_AI_BASE_URL`	no	`https://api.kie.ai/api/v1`	URL base de la API
`KIE_AI_MODEL`	no	`nano-banana-pro`	Modelo de generación de imágenes
`KIE_AI_OUTPUT_DIR`	no	`output`	Directorio donde se guardan las imágenes generadas
`KIE_AI_TIMEOUT_SECONDS`	no	`90`	Timeout HTTP por solicitud
`KIE_AI_POLL_INTERVAL_SECONDS`	no	`3`	Segundos entre sondeos del estado de la tarea
`KIE_AI_POLL_TIMEOUT_SECONDS`	no	`300`	Segundos máximos de espera para que una tarea se complete
`KIE_AI_HTTP_RETRIES`	no	`3`	Intentos de reintento ante errores HTTP transitorios
`KIE_AI_HTTP_RETRY_BACKOFF_SECONDS`	no	`1.5`	Retardo de backoff inicial para los reintentos (se duplica en cada intento)

Si usas fish, las variables universales persisten entre sesiones y llegan a cualquier proceso hijo — sin necesidad de .env:

set -Ux KIE_AI_API_KEY your-api-key-here
set -Ux KIE_AI_MODEL nano-banana-pro
set -Ux KIE_AI_OUTPUT_DIR output

El servidor también lee un .env desde el directorio de trabajo o el directorio del binario — simplemente no lo subas al repositorio. Las imágenes acaban en KIE_AI_OUTPUT_DIR a menos que pases un output_path por llamada.

Por qué un servidor en lugar de una llamada directa a la API

El valor aquí no es la generación en sí — de eso se encarga Kie AI. Es todo lo que la rodea: sondear con timeouts sensatos, reintentar fallos HTTP transitorios con backoff exponencial, descargar el resultado antes de que la URL expire, y ejecutar un lote de forma concurrente sin fundir el límite de tasa. Incorporar eso a un servidor significa que el modelo nunca tiene que razonar sobre ciclos de vida de tareas. Dice "hazme cuatro imágenes hero en este estilo" y recibe cuatro archivos de vuelta.

Es el mismo patrón detrás de mis otros servidores MCP — envolver un backend capaz, exponer exactamente las operaciones que un agente necesita, y mantener los secretos en el env del host, donde nunca se filtran a una transcripción.

El proyecto está abierto en GitHub: github.com/artschekoff/kie-ai-mcp — construido con Go. Issues y pull requests bienvenidos.