logo
pub

Como Usar o FastAPI pra Envolver a API do Luma AI: Um Guia Prático

1. Introdução ao Lumalabs e Dream Machine

O Lumalabs é uma empresa inovadora que tá fazendo sucesso no mundo da IA e aprendizado de máquina. Uma das coisas mais legais que eles têm é o Dream Machine, que permite gerar vídeos a partir de texto ou imagens usando uma IA super avançada. Agora a gente conseguiu acesso a uma API RESTful não oficial pra isso, e eu vou te mostrar como usar com o FastAPI. Seja você um desenvolvedor querendo integrar a geração de vídeos de IA no seu app ou só tá afim de brincar com as capacidades do Luma, esse guia vai te dar uma mão.

Documentação da API: API Luma

2. Configurando o FastAPI

2.1. Instalando o FastAPI

Primeiro de tudo, a gente precisa instalar o FastAPI. Se você ainda não tiver, é bem simples. É só rodar:

pip install fastapi

E também vai precisar de um servidor ASGI pra rodar sua aplicação FastAPI, tipo o uvicorn:

pip install uvicorn

2.2. Criando um App Básico com FastAPI

Vamos começar com um app bem básico do FastAPI só pra garantir que tá tudo funcionando. Crie um novo arquivo Python chamado main.py:

from fastapi import FastAPI

app = FastAPI()

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

Agora, roda o servidor usando o uvicorn:

uvicorn main:app --reload

Acesse http://127.0.0.1:8000/ no seu navegador e você deve ver a mensagem "Olá, IA Luma!".

3. Envolvendo a API Luma

3.1. Configurando o Endpoint de POST

Agora, vamos criar um endpoint de POST no FastAPI que envolve a API Luma pra gerar vídeos. A ideia aqui é fazer uma interface limpa e simples pra uso interno.

Aqui tá como você pode configurar esse 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"  # Substitua isso pelo seu 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. Entendendo o Endpoint

  • Preparação do Payload: A gente junta os dados que precisa, tipo o prompt, a URL de callback, e as URLs das imagens, usando a função Form do FastAPI. Isso ajuda a criar a estrutura de dados que a API Luma espera.

  • Autorização: A gente inclui o token Bearer nos cabeçalhos pra acessar a API de forma segura.

  • Fazendo a Requisição para a API: Depois, fazemos uma requisição POST pra API Luma e retornamos a resposta em formato JSON.

4. Testando Sua API

4.1. Usando a Documentação Integrada do FastAPI

Uma das coisas legais do FastAPI é que ele gera a documentação automaticamente. Assim que seu app estiver rodando, é só acessar http://127.0.0.1:8000/docs, e você vai ver uma página de documentação interativa bem legal.

4.2. Fazendo um Teste da Requisição

Você pode testar facilmente seu novo endpoint /generate-video/ direto da documentação. Preenche os campos do formulário com um prompt de exemplo, a URL de callback, e opcionalmente, as URLs das imagens. Depois, é só clicar em "Execute" pra ver o resultado.

5. Lidando com o Callback

5.1. Configurando o Endpoint de Callback

Depois que o vídeo for gerado, a API Luma vai enviar uma requisição POST pra URL de callback que você forneceu. Vamos configurar um endpoint pra lidar com isso:

from fastapi import Request

@app.post("/api/cb_task/")
async def handle_callback(request: Request):
    callback_data = await request.json()
    # Faça algo com os dados do callback, como salvar a URL do vídeo no banco de dados
    return {"status": "Callback recebido", "data": callback_data}

5.2. Processando os Dados do Callback

No manipulador de callback, você pode processar os dados do jeito que achar melhor. Por exemplo, você pode querer armazenar a URL do vídeo no seu banco, ou desencadear outra ação com base na resposta.

6. Conclusão

Você acabou de envolver a API Luma usando FastAPI, facilitando muito a integração da geração de vídeos com IA nos seus projetos. Se você tá trabalhando em um aplicativo grande ou só explorando as possibilidades com IA, essa configuração te dá uma ferramenta poderosa na palma da mão. Boa codificação!

SHARE