logo
pub

Hoe je FastAPI kunt gebruiken om de API van Luma AI te verpakken: Een praktische gids

1. Introductie van Lumalabs en Dream Machine

Dus, Lumalabs is echt een toffe firma die flink indruk maakt in de wereld van AI en machine learning. Een van z'n beste functies is Dream Machine, waarmee je video's kunt maken van tekst of beelden met behulp van top AI. En nu hebben we een onofficiële RESTful API voor deze functie, en ik ga je laten zien hoe je het kunt omarmen met FastAPI. Of je nou een ontwikkelaar bent die AI-video generatie in je app wil integreren of gewoon wilt experimenteren met de mogelijkheden van Luma, deze gids helpt je om te beginnen.

API Documentatie: Luma API

2. FastAPI Instellen

2.1. FastAPI Installeren

Laten we beginnen met het opzetten van FastAPI. Als je het nog niet hebt, kun je het snel installeren met pip. Gewoon even dit commando uitvoeren:

pip install fastapi

Je hebt ook een ASGI-server nodig om je FastAPI-app te draaien, zoals uvicorn:

pip install uvicorn

2.2. Een Basis FastAPI App Maken

Laten we beginnen met een heel simpele FastAPI app om te checken of alles goed is ingesteld. Maak een nieuw Python bestand aan met de naam main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hallo, Luma AI!"}

Nu, run de server met uvicorn:

uvicorn main:app --reload

Ga naar http://127.0.0.1:8000/ in je browser, en je zou het "Hallo, Luma AI!" bericht moeten zien.

3. De Luma API Omhulen

3.1. Je POST Endpoint Instellen

Oké, laten we nu een POST endpoint maken in FastAPI dat de Luma API omhuldt voor het genereren van video's. Het idee is om een mooie en simpele interface te maken voor intern gebruik.

Zo kun je dat endpoint instellen:

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"  # Vervang dit met je echte token

@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. Het Endpoint Uiteenzetten

  • Payload Voorbereiding: We verzamelen de nodige data zoals prompt, callback URL, en beeld-URL's met FastAPI's Form functie. Dit helpt om de form-data structuur te creëren die de Luma API verwacht.

  • Autoriserie: We voegen de Bearer token toe in de headers voor veilige toegang tot de API.

  • De API-aanroep Doen: Dan maken we een POST-aanroep naar de Luma API en geven de reactie terug als JSON.

4. Je API Testen

4.1. Gebruik maken van FastAPI’s ingebouwde Docs

Een van de gave dingen van FastAPI zijn de automatisch gegenereerde docs. Zodra je app draait, ga je naar http://127.0.0.1:8000/docs, en je ziet een mooie interactieve documentatiepagina.

4.2. Een Testverzoek Doen

Je kunt je nieuwe /generate-video/ endpoint makkelijk testen vanuit de docs. Vul de formuliervelden in met een voorbeeldprompt, callback URL, en eventueel beeld-URL's, en druk op "Execute" om het resultaat te zien.

5. De Callback Afhandelen

5.1. De Callback Endpoint Instellen

Nadat de video is gegenereerd, zal de Luma API een POST verzoek sturen naar de callback URL die je hebt opgegeven. Laten we een endpoint instellen om dat te verwerken:

from fastapi import Request

@app.post("/api/cb_task/")
async def handle_callback(request: Request):
    callback_data = await request.json()
    # Doe iets met de callback data, zoals de video-URL opslaan in een database
    return {"status": "Callback ontvangen", "data": callback_data}

5.2. De Callback Data Verwerken

In de callback handler kun je de data verwerken zoals je wilt. Bijvoorbeeld, je zou de video-URL in je database willen opslaan of een andere actie willen triggeren op basis van de respons.

6. Afsluiten

Je hebt zojuist de Luma API omhuldt met FastAPI, waardoor het super makkelijk is om AI-gestuurde video-generatie in je projecten te integreren. Of je nu aan een grote applicatie werkt of gewoon wilt ontdekken wat mogelijk is met AI, deze setup geeft je een krachtig hulpmiddel binnen handbereik. Veel plezier met coderen!

SHARE