LangChain Agentic AI Tutorial mit einer OpenAI-kompatiblen API

Was du vor dem Start benötigst

Du benötigst Python 3.10 oder neuer, einen API-Schlüssel und einige Pakete. Den Schlüssel erhältst du auf der API-Schlüssel-Seite: Melde dich mit Google oder mit E-Mail und Passwort an, und beanspruche das $0,50 Testguthaben mit einem Klick. Der Test-Schlüssel erlaubt 2 parallele Anfragen und 60 pro Minute, was für alles in diesem Artikel ausreicht, wenn du jeweils einen Agenten ausführst.

Copypip install langchain-openai langchain-core langgraph
export API_KEY="paste-your-key-here"

Die API stellt POST /v1/chat/completions und GET /v1/models bereit. LangChain benötigt nur das erste. Das Modell ist ein einzelnes Open-Weight-Modell, das darauf abgestimmt ist, ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene zu antworten; es wird von einem unabhängigen Anbieter betrieben und ist nicht die offizielle API eines Modellherstellers. Die Dokumentation listet die Header und Limits auf, falls du sie neben deinem Editor benötigst.

Wie die Komponenten mit der API verknüpft sind

Es hilft zu wissen, was LangChain im Netzwerk tut. Eine HumanMessage wird zu einer Nachricht mit der Rolle user. Eine AIMessage wird zu assistant, und wenn sie Tool-Aufrufe enthält, erscheinen diese in der Assistant-Nachricht als tool_calls-Array. Eine ToolMessage wird zur Rolle tool mit der passenden Call-ID. Der System-Prompt geht als Rolle system voran.

Diese Zuordnung ist wichtig für das Debugging. Wenn sich ein Agent seltsam verhält, gib die Nachrichtenliste vor jedem Aufruf aus und lies sie wie ein Protokoll. Du wirst das Problem meist innerhalb einer Minute finden: ein leeres Tool-Ergebnis, eine Call-ID, die nicht übereinstimmt, oder einen Verlauf, der viel länger geworden ist als erwartet. Das Wort „agentic“ kann dies wie Magie klingen lassen, aber jeder Schritt ist eine normale Chat-Vervollständigungsanfrage.

Schritt 1: ChatOpenAI verbinden

Die gesamte Integration besteht aus drei Argumenten. LangChain erstellt standardmäßige OpenAI-ähnliche Anfragen, sodass der Server den Unterschied nicht erkennen kann.

Copyimport os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.uncensoredvideo.cc/v1",
    api_key=os.environ["API_KEY"],
    temperature=0.7,
    max_retries=2,
)

print(llm.invoke("Name three beats of a heist scene, one line each.").content)

Wenn dies drei Zeilen ausgibt, funktioniert die Verbindung. Wenn du einen 401-Fehler erhältst, überprüfe den Schlüssel. Wenn du einen 404-Fehler erhältst, überprüfe, ob die URL mit /v1 endet und keinen zusätzlichen Pfad hat. max_retries ist eine Client-Option und hilft bei den temporären 429-Antworten, die Retry-After: 5 enthalten.

Streaming funktioniert auf die gleiche Weise, wie du es bei jedem OpenAI-Modell verwenden würdest: Rufe llm.stream(...) auf und iteriere. Der letzte Chunk enthält die Nutzungsinformationen, sodass du Token-Anzahlen pro Aufruf protokollieren kannst.

Schritt 2: Tools definieren

Ein Agent ist eine Schleife: Das Modell liest die Konversation, antwortet entweder oder fragt nach einem Tool, dein Code führt das Tool aus, und das Ergebnis geht zurück an das Modell. Die folgenden Tools sind einfache Python-Funktionen. Sie sind bewusst langweilig, weil es darum geht, die Mechanik zu sehen.

Copyfrom langchain_core.tools import tool

@tool
def word_count(text: str) -> int:
    """Count the words in a piece of text."""
    return len(text.split())

@tool
def spoken_minutes(words: int, words_per_minute: int = 150) -> float:
    """Estimate how many minutes a script takes to read aloud."""
    return round(words / words_per_minute, 2)

tools = [word_count, spoken_minutes]

Der Docstring und die Typ-Hinweise werden zur Tool-Beschreibung und zum Schema, das das Modell sieht. Schreibe sie so, als würdest du einen Kollegen instruieren. Ein vager Docstring ist der häufigste Grund, warum ein Agent das falsche Tool wählt. Wenn du Skripte für Video schreibst, skaliert das gleiche Muster auf Tools, die Shot-Listen abrufen oder ein Längenbudget prüfen, ein Thema, das auf der Sora 2 Script Generator-Seite behandelt wird.

Schritt 3: Agent-Schleife manuell ausführen

Die vorgefertigten Helfer verbergen die Schleife. Sie einmal selbst zu schreiben, macht jedes spätere Debugging einfacher.

Copyfrom langchain_core.messages import HumanMessage, ToolMessage

by_name = {t.name: t for t in tools}
llm_tools = llm.bind_tools(tools)

messages = [HumanMessage(
    "Here is a draft: 'The vault door hums. Nina counts to three, "
    "then cuts the power.' How many words is it, and how long is it read aloud?"
)]

for step in range(6):
    ai = llm_tools.invoke(messages)
    messages.append(ai)
    if not ai.tool_calls:
        break
    for call in ai.tool_calls:
        result = by_name[call["name"]].invoke(call["args"])
        messages.append(ToolMessage(content=str(result), tool_call_id=call["id"]))

print(messages[-1].content)

Drei Details sind wichtig. Die range(6)-Grenze verhindert, dass ein verwirrtes Modell endlos in einer Schleife landet, und sie begrenzt auch deine Ausgaben. Die tool_call_id muss mit dem Aufruf übereinstimmen, auf den sie antwortet. Und das Modell kann mehrere Tools in einer Antwort anfordern, weshalb die innere Schleife eine Liste verarbeitet.

Unter der Haube trägt die Anfrage ein tools-Array und die Antwort enthält tool_calls, wobei Ergebnisse als Nachrichten mit role: "tool" zurückgegeben werden. Du kannst ein bestimmtes Tool mit tool_choice erzwingen, was LangChain als Argument an bind_tools verfügbar macht.

Schritt 4: Vorgefertigten LangGraph-Agenten verwenden

Sobald die manuelle Schleife Sinn ergibt, spart der vorgefertigte Agent Zeilen. Er verwendet dasselbe Modell und dieselben Tools.

Copyimport os
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.uncensoredvideo.cc/v1",
    api_key=os.environ["API_KEY"],
)

agent = create_react_agent(llm, tools)
out = agent.invoke({"messages": [("user", "How long is a 450 word script read aloud?")]})
print(out["messages"][-1].content)

LangChain und LangGraph ändern ihre APIs zwischen Releases, und einige Helfer wurden umbenannt oder verschoben. Wenn ein Import fehlschlägt, überprüfe die aktuelle LangChain-Dokumentation für den entsprechenden Agenten-Konstruktor. Der Verbindungsteil, ChatOpenAI mit einer Base URL, bleibt gleich.

Die Wahl zwischen einer Schleife und einem Graphen

Die manuell geschriebene Schleife reicht für Agenten aus, die aus wenigen Tools auswählen und stoppen. Sie ist leicht lesbar, leicht zu protokollieren und hat keine Framework-Überraschungen. Wechsle zu LangGraph, wenn du Verzweigungen benötigst, die vom Zustand abhängen: ein Überprüfungsschritt, der Arbeit für einen weiteren Durchlauf zurücksendet, eine menschliche Genehmigung vor einem riskanten Tool-Aufruf oder mehrere spezialisierte Sub-Agenten, die Ergebnisse aneinander weitergeben.

Was auch immer du wählst, halte jeden Knoten klein und gib ihm eine einzige Aufgabe. Ein Planungsknoten, der eine kurze nummerierte Liste als JSON ausgibt, ein Ausführungsknoten, der Tools ausführt, und ein Schreibknoten, der den Endtext erzeugt, sind einfacher zu testen als ein einziger riesiger Prompt. Sie ermöglichen auch unterschiedliche Temperaturen: niedrig für Planung und Tool-Nutzung, höher für den Schreibschritt. Da jeder Knoten ein normaler Chat-Vervollständigungsaufruf ist, dienen derselbe Schlüssel, dieselbe URL und derselbe Modellname allen, und die Kosten sind einfach die Summe der Aufrufe.

Eine letzte Gewohnheit: Gib die laufende Token-Gesamtzahl aus. Agenten, die in einer Demo günstig aussehen, können bei einer unordentlichen echten Aufgabe das Zehnfache ausgeben, und die Nutzungszahlen in jeder Antwort machen dies bei der ersten Ausführung sichtbar, bevor es zu einer Überraschung auf deinem Guthaben wird.

Speicher, Tests und strukturierte Ausgabe

Die obige Schleife vergisst alles, wenn das Skript endet. Der einfachste Speicher ist die Nachrichtenliste selbst: Behalte sie zwischen Benutzereingaben bei, hänge jede neue Frage an und kürze die ältesten Nachrichten, wenn sie lang wird. Für lange Sitzungen ersetze alte Nachrichten durch eine kurze Zusammenfassung, die vom Modell geschrieben wird. Da Eingaben pro Token abgerechnet werden, schlägt eine 500-Token-Zusammenfassung 20.000 Token rohen Verlaufs sowohl bei den Kosten als auch bei der Fokussierung.

Das Testen von Agenten besteht hauptsächlich darin, beobachtbares Verhalten zu prüfen. Setze temperature auf 0 oder übergebe einen festen seed, den die API durchreicht, damit Ausführungen wiederholbarer sind. Schreibe dann eine Handvoll Fragen, bei denen du weißt, welches Tool aufgerufen werden sollte, und prüfe die Tool-Namen und Argumente in der Nachrichtenliste, nicht die genaue Wortwahl der Antwort. Führe diese Tests nach jeder Änderung an einem Prompt oder einer Tool-Beschreibung durch. Das Ändern eines Docstrings kann ändern, welches Tool das Modell auswählt, und ein Test ist die günstigste Möglichkeit, dies festzustellen.

Protokolliere drei Dinge für jede Ausführung: die Anzahl der Schritte, die Tool-Aufrufe mit ihren Argumenten und die Token-Nutzung. Wenn eine Ausführung fehlschlägt, sagen dir diese drei Zeilen, ob das Modell schlecht gewählt hat, ein Tool fehlgeschlagen ist oder die Schleife die Schritte ausgeschöpft hat.

Strukturierte Ausgabe und JSON-Modus

Agenten müssen oft Daten zurückgeben, keinen Text. Die API unterstützt JSON-Modus über response_format: {"type":"json_object"}. In LangChain kannst du dies mit llm.bind(response_format={"type": "json_object"}) anfordern. Sage dem Modell im Prompt, dass die Antwort ein JSON-Objekt sein muss, und benenne die erwarteten Schlüssel, analysiere dann den String und validiere ihn mit Pydantic. Verlass dich nicht darauf, dass der Parse-Schritt immer gelingt; packe ihn in einen Retry, der den Fehlertext einmal an das Modell zurücksendet.

Fallstricke und wie man sie behebt

• Schlechte Tool-Argumente. Ein Open-Weight-Modell sendet manchmal einen String, wo du eine Ganzzahl deklariert hast. Validiere Argumente, gib eine kurze Fehlermeldung vom Tool zurück und lasse das Modell sich im nächsten Schritt korrigieren.
• Unkontrollierte Schleifen. Begrenze immer die Iterationen. Protokolliere jeden Schritt während der Entwicklung.
• Parallele Agenten. Ein voller Schlüssel erlaubt 8 parallele Anfragen. Wenn du einen Batch ausführst, setze config={"max_concurrency": 4} auf llm.batch, um Spielraum zu lassen. Das Überschreiten des Limits gibt 429 mit dem Code concurrency zurück; das Überschreiten von 300 Anfragen pro Minute gibt rate_limited zurück.
• Streaming plus Tools. Eine gestreamte Anfrage hält ihre Concurrency-Position bis zum Stream-Ende, also starte keine neuen Aufrufe innerhalb eines Stream-Handlers auf einem Testschlüssel.
• Wachsende Historie. Jeder Schritt sendet die vollständige Nachrichtenliste erneut. Das Kontextfenster umfasst 100.000 Token, aber du zahlst für Input bei jedem Aufruf.

Was ein Agenten-Lauf kostet

Nimm einen bescheidenen Agenten, der 4 Modellaufrufe ausführt, um eine Aufgabe zu erledigen, mit einem durchschnittlichen Prompt von 3.000 Token und 200 Output-Token pro Aufruf. Input: 4 x 3.000 = 12.000 Token, das sind 12.000 x 0,15 $ / 1.000.000 = 0,0018 $. Output: 4 x 200 = 800 Token, das sind 0,0004 $. Ein Durchlauf kostet 0,0022 $, also kosten 1.000 Durchläufe 2,20 $. Das Testguthaben von 0,50 $ deckt etwa 227 solcher Durchläufe ab. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, und Guthaben verfällt nie. Sieh dir die Preisgestaltung für Aufladungsbeträge und Boni an. Diese Website akzeptiert nur Krypto, USDT auf TRC20 oder USDC auf Base.

Weitere Anleitungen

• Roleplay mit KI: Kostenlose Testphase und echte Kosten
• Erstelle eine unzensierte KI-Suchmaschine mit Tool Calling
• Sora 2 API: Unzensierter Text-zu-Video-KI-Skriptgenerator