logo
pub

Cómo usar FastAPI para envolver la API de Luma AI: Una guía práctica

1. Introducción a Lumalabs y Dream Machine

Lumalabs es una empresa innovadora que ha estado destacándose en el mundo de la IA y el aprendizaje automático. Una de sus características más chulas es Dream Machine, que te permite generar videos a partir de texto o imágenes usando IA de última generación. Y bueno, hemos conseguido una API RESTful no oficial para esto, y hoy te voy a mostrar cómo envolverla usando FastAPI. Así que, si eres un desarrollador que quiere integrar la generación de videos con IA en tu app, o simplemente quieres experimentar con las capacidades de Luma, este guía te va a ayudar a empezar.

Documentación de la API: Luma API

2. Configurando FastAPI

2.1. Instalar FastAPI

Primero lo primero, necesitamos configurar FastAPI. Si no lo tienes instalado todavía, puedes hacerlo rápidamente con pip. Solo ejecuta:

pip install fastapi

También necesitas un servidor ASGI para correr tu aplicación FastAPI, como uvicorn:

pip install uvicorn

2.2. Creando una App Básica de FastAPI

Vamos a empezar con una app muy básica de FastAPI para asegurarnos de que todo esté en orden. Crea un nuevo archivo Python llamado main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "¡Hola, Luma IA!"}

Ahora, ejecuta el servidor usando uvicorn:

uvicorn main:app --reload

Ve a http://127.0.0.1:8000/ en tu navegador, y deberías ver el mensaje "¡Hola, Luma IA!".

3. Envuelto la API de Luma

3.1. Configurando tu Endpoint POST

Ahora, vamos a crear un endpoint POST en FastAPI que envuelva la API de Luma para generar videos. La idea es hacer una interfaz limpia y sencilla para uso interno.

Aquí te muestro cómo puedes configurar el endpoint:

import requests
from fastapi import FastAPI, Form

app = FastAPI()

LUMA_API_URL = "https://api.lumaapi.com/api/v1/generation/add"
LUMA_API_TOKEN = "sk-xxx"  # Reemplaza esto con tu token real

@app.post("/generate-video/")
def generate_video(
    prompt: str = Form(...),
    callback_url: str = Form(...),
    image_url: str = Form(None),
    image_end_url: str = Form(None),
    aspect_ratio: str = Form("16:9")
):
    payload = {
        'arg_prompt': prompt,
        'callback': callback_url,
        'arg_image_url': image_url,
        'arg_image_end_url': image_end_url,
        'arg_aspect_ratio': aspect_ratio
    }
    headers = {
        'Authorization': f'Bearer {LUMA_API_TOKEN}'
    }

    response = requests.post(LUMA_API_URL, headers=headers, data=payload)

    return response.json()

3.2. Desglosando el Endpoint

  • Preparación del Payload: Recogemos los datos necesarios como el prompt, el URL del callback, y las URLs de las imágenes usando la función Form de FastAPI. Esto ayuda a crear la estructura de datos que espera la API de Luma.

  • Autorización: Incluimos el token Bearer en los headers para acceder a la API de forma segura.

  • Realizando la Solicitud a la API: Luego, hacemos una solicitud POST a la API de Luma y devolvemos la respuesta en formato JSON.

4. Probando Tu API

4.1. Usando la Documentación Incorporada de FastAPI

Una de las cosas geniales de FastAPI es que genera automáticamente la documentación. Una vez que tu app esté corriendo, ve a http://127.0.0.1:8000/docs, y verás una página de documentación interactiva muy buena.

4.2. Haciendo una Solicitud de Prueba

Puedes probar fácilmente tu nuevo endpoint /generate-video/ directamente desde la documentación. Rellena los campos del formulario con un prompt de ejemplo, la URL del callback y, opcionalmente, las URLs de las imágenes. Luego, dale a "Ejecutar" para ver el resultado.

5. Manejo del Callback

5.1. Configurando el Endpoint de Callback

Después de que el video sea generado, la API de Luma enviará una solicitud POST a la URL del callback que proporcionaste. Vamos a configurar un endpoint para manejar eso:

from fastapi import Request

@app.post("/api/cb_task/")
async def handle_callback(request: Request):
    callback_data = await request.json()
    # Haz algo con los datos del callback, como guardar la URL del video en una base de datos
    return {"status": "Callback recibido", "data": callback_data}

5.2. Procesando los Datos del Callback

En el manejador del callback, puedes procesar los datos como quieras. Por ejemplo, podrías querer almacenar la URL del video en tu base de datos o desencadenar otra acción basada en la respuesta.

6. Conclusiones

Acabas de envolver la API de Luma usando FastAPI, haciendo super fácil integrar la generación de videos con IA en tus proyectos. Ya sea que estés trabajando en una aplicación grande o simplemente explorando lo que es posible con la IA, esta configuración te da una herramienta poderosa al alcance de tu mano. ¡Feliz codificación!

SHARE