logo
pub

Wie du FastAPI nutzt, um die API von Luma AI einzuwickeln: Ein praktischer Leitfaden

1. Einführung in Lumalabs und Dream Machine

Hey! Lumalabs ist eine echt coole Firma, die richtig viel Aufsehen in der AI- und Machine Learning-Welt erregt. Eine ihrer beeindruckendsten Funktionen ist Dream Machine. Damit kannst du mit modernster AI Videos aus Text oder Bildern erstellen. Und jetzt haben wir einen inoffiziellen RESTful API dafür ergattert! Ich zeig dir, wie du das mit FastAPI einwickeln kannst. Egal, ob du ein Entwickler bist, der AI-Videoerstellung in deine App integrieren will, oder einfach nur mit Luma Spaß haben möchtest, diese Anleitung hilft dir, loszulegen.

API-Dokumentation: Luma API

2. FastAPI Einrichten

2.1. FastAPI Installieren

Erstmal müssen wir FastAPI einrichten. Wenn du es noch nicht installiert hast, kein Problem. Hol es dir einfach schnell mit pip. Einfach diesen Befehl ausführen:

pip install fastapi

Du brauchst auch einen ASGI-Server, um deine FastAPI-Anwendung zu bedienen, wie zum Beispiel uvicorn:

pip install uvicorn

2.2. Eine Grundlegende FastAPI-App Erstellen

Lass uns mit einer ganz einfachen FastAPI-App anfangen, um sicherzustellen, dass alles korrekt eingerichtet ist. Erstelle eine neue Python-Datei, nenn sie main.py:

from fastapi import FastAPI

app = FastAPI()

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

Jetzt starte den Server mit uvicorn:

uvicorn main:app --reload

Geh jetzt in deinen Browser zu http://127.0.0.1:8000/ und du solltest die Nachricht "Hallo, Luma AI!" sehen.

3. Die Luma API Einwickeln

3.1. Deinen POST-Endpunkt Einrichten

Als Nächstes erstellen wir einen POST-Endpunkt in FastAPI, der die Luma API für die Video-Generierung einwickelt. Die Idee ist, eine einfache und saubere Schnittstelle für den internen Gebrauch zu schaffen.

So kannst du den Endpunkt einrichten:

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"  # Ersetze dies mit deinem echten 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. Den Endpunkt Aufschlüsseln

  • Payload-Vorbereitung: Wir sammeln die nötigen Daten wie den Prompt, die Callback-URL und die Bild-URLs mit FastAPI’s Form Funktion. So erstellen wir die Formulardatenstruktur, die die Luma API erwartet.

  • Autorisierung: Wir fügen das Bearer-Token in die Header ein, um sicher auf die API zugreifen zu können.

  • API-Anfrage Stellen: Dann machen wir eine POST-Anfrage an die Luma API und geben die Antwort als JSON zurück.

4. Deine API Testen

4.1. FastAPI’s Eingebaute Dokumentation Nutzen

Eines der coolen Dinge an FastAPI ist die automatisch generierte Dokumentation. Sobald deine App läuft, geh zu http://127.0.0.1:8000/docs, und du bekommst eine schicke interaktive Dokumentationsseite zu sehen.

4.2. Eine Testanfrage Machen

Du kannst ganz einfach deinen neuen /generate-video/ Endpunkt direkt aus der Dokumentation testen. Füll die Formularfelder mit einem Beispiel-Prompt, der Callback-URL und optional, Bild-URLs aus, und drück "Execute", um das Ergebnis zu sehen.

5. Den Callback Handhaben

5.1. Den Callback-Endpunkt Einrichten

Nachdem das Video generiert wurde, sendet die Luma API eine POST-Anfrage an die Callback-URL, die du angegeben hast. Lass uns einen Endpunkt dafür einrichten:

from fastapi import Request

@app.post("/api/cb_task/")
async def handle_callback(request: Request):
    callback_data = await request.json()
    # Mach was mit den Callback-Daten, zum Beispiel die Video-URL in einer Datenbank speichern
    return {"status": "Callback empfangen", "data": callback_data}

5.2. Die Callback-Daten Verarbeiten

Im Callback-Handler kannst du die Daten verarbeiten, wie du willst. Zum Beispiel könntest du die Video-URL in deiner Datenbank speichern oder eine andere Aktion auslösen, basierend auf der Antwort.

6. Zusammenfassung

Du hast die Luma API mit FastAPI umschlossen und damit ist es super einfach, die AI-gestützte Videoerstellung in deine Projekte zu integrieren. Egal, ob du an einer großen Anwendung arbeitest oder einfach nur ausprobieren möchtest, was mit AI möglich ist, diese Einrichtung gibt dir ein mächtiges Werkzeug an die Hand. Viel Spaß beim Coden!

SHARE