LangChain Agentic AI-Dokumentation: Tools und JSON-Modus
Die meisten LangChain Agentic AI-Dokumentationen gehen von einer eigenen Modellklasse des Anbieters aus, aber jeder OpenAI-kompatible Endpunkt funktioniert mit ChatOpenAI, sobald du eine Base URL einstellst. Dieser Leitfaden bindet LangChain an diese API und baut schrittweise einen Agenten mit Function Calling auf.
Aktualisiert
Wichtige Punkte
- Verwende ChatOpenAI mit base_url, das auf diese API eingestellt ist, und model auf
uncensored. - Function Calling und JSON-Modus werden unterstützt, also funktionieren bind_tools und response_format wie dokumentiert.
- Begrenze Agent-Schleifen, validiere Tool-Argumente und halte max_concurrency bei einem vollen Schlüssel bei oder unter 8.
- Streaming über SSE gibt am Ende die Token-Nutzung zurück, was dir hilft, die Kosten jedes Agentenlaufs zu verfolgen.

Was du vor dem Start benötigst
Wenn du LangChain Agentic AI-Dokumentation liest und dich fragst, was sich ändert, wenn das Modell nicht vom Anbieter in den Beispielen stammt, ist die Antwort: sehr wenig. Ein Agent in LangChain ist eine Schleife: Das Modell liest die Konversation, entscheidet, ob es ein Tool aufrufen soll, dein Code führt das Tool aus, und das Ergebnis geht zurück an das Modell, bis es eine endgültige Antwort liefert. Der Model-Endpunkt muss nur Chat Completions mit Function Calling unterstützen, und das tut diese API.
Du brauchst drei Dinge: einen API-Schlüssel von der Schlüssel-Seite, Python 3.10 oder neuer und die folgenden Pakete. Die Base URL ist https://api.unlimitedaiapi.com/v1 und die Modell-ID ist uncensored. Es ist ein Open-Weight-Modell, das von einem unabhängigen Anbieter betrieben wird, also gibt es keine Modellliste zur Auswahl; GET /v1/models gibt es zur Client-Erkennung zurück.
pip install -U langchain langchain-openai
export UNLIMITED_API_KEY="your-key-here"Schritt 1: ChatOpenAI mit dem Endpunkt verbinden
LangChains ChatOpenAI-Klasse nimmt eine benutzerdefinierte base_url entgegen. Alles andere daran bleibt gleich, einschließlich der Varianten invoke, stream, batch und async.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0.2,
)
print(llm.invoke("Reply with one short sentence.").content)
Wenn dies einen Satz ausgibt, sind Authentifizierung, Routing und der Modellname korrekt. Die Authentifizierung erfolgt über den Standard-Authorization: Bearer-Header, den die Klasse für dich hinzufügt. Ein häufiger Fehler ist das Weglassen von /v1 in der Base URL, was normalerweise dazu führt, dass der erste Aufruf fehlschlägt.
Schritt 2: Tools definieren und binden
Tools sind einfache Python-Funktionen mit einem Docstring. Der Docstring und die Typenhinweise werden zum Schema, das das Modell sieht, also schreibe sie so, als würdest du die Funktion einem neuen Kollegen erklären.
import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
llm_with_tools = llm.bind_tools([get_order_status])
ai = llm_with_tools.invoke("Where is order A100?")
print(ai.tool_calls)
Die gedruckte Liste enthält einen Aufruf mit dem Namen get_order_status und Argumenten wie {"order_id": "A100"}. Unter der Haube sendet LangChain deine Funktion als Eintrag im tools-Array der Chat-Completions-Anfrage, und die API unterstützt tools, tool_choice und gestreamte tool_calls. Um einen Tool-Aufruf zu erzwingen, übergebe tool_choice an bind_tools.
Warum die Temperatur niedrig ist
Agenten verketten mehrere Modellaufrufe, daher kann ein falsch formatiertes Argument einen Lauf durcheinander bringen. Eine Temperatur von 0 bis 0,2 macht die Tool-Auswahl wiederholbarer. Erhöhe sie nur für den letzten Antwort-Schritt, wenn du abwechslungsreicheren Text möchtest.
Schritt 3: Agent-Schleife ausführen
Die Schleife selbst zu schreiben, braucht nur etwa fünfzehn Zeilen und zeigt genau, was in jedem Schritt passiert, was hilft, wenn etwas schiefgeht. Tool-Ergebnisse werden als ToolMessage-Objekte an das Modell zurückgesendet, die als role: "tool"-Nachrichten auf der Leitung erscheinen.
import os
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
tools = {"get_order_status": get_order_status}
llm_with_tools = llm.bind_tools(list(tools.values()))
messages = [HumanMessage("Where is order A100, and what about A101?")]
for _ in range(5): # hard cap on loop length
ai = llm_with_tools.invoke(messages)
messages.append(ai)
if not ai.tool_calls:
break
for call in ai.tool_calls:
result = tools[call["name"]].invoke(call["args"])
messages.append(ToolMessage(content=str(result), tool_call_id=call["id"]))
print(ai.content)
Beachte range(5). Ein Agent ohne Schrittlimit kann in einer Schleife endlos auf ein verwirrendes Tool-Ergebnis reagieren, und jeder Durchlauf kostet Input-Token für die gesamte bisherige Konversation. Fünf ist eine vernünftige Obergrenze für einfache Aufgaben; erhöhe sie gezielt.
Vorgefertigten Agent-Helper verwenden
Neuere LangChain-Versionen liefern einen Helper, der diese Schleife für dich ausführt. Der Name und der Import-Pfad haben sich zwischen den Versionen verschoben, also bestätige sie gegen die Docs der installierten Version. In der aktuellen 1.x-Reihe sieht das so aus:
import os
from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
agent = create_agent(llm, tools=[get_order_status], system_prompt="You are a concise support assistant.")
result = agent.invoke({"messages": [{"role": "user", "content": "Where is order A100?"}]})
print(result["messages"][-1].content)
Verwende den Helper, wenn du das Standardmuster möchtest, und die manuell geschriebene Schleife, wenn du benutzerdefinierte Abbruchregeln, Logging pro Schritt oder Tool-Ergebnisse brauchst, die du filtern möchtest, bevor das Modell sie sieht.
Strukturierte Ausgabe mit JSON-Modus
Agenten müssen Daten oft an anderen Code übergeben, wie einen Plan, eine Klassifizierung oder eine Liste extrahierter Felder. Der JSON-Modus zwingt die Antwort in ein gültiges JSON-Objekt. In LangChain kannst du es über bind übergeben:
import json
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke(
"Extract the city and country from: 'I moved to Lyon, France last spring.' "
"Answer as JSON with the keys city and country."
)
print(json.loads(msg.content))
Erwähne das Wort JSON im Prompt und beschreibe die Schlüssel, die du erwartest, wie im Beispiel. Der JSON-Modus garantiert die Syntax, nicht dein Schema, also validiere das geparste Objekt (z. B. mit Pydantic) weiterhin und behandle einen fehlenden Schlüssel.
Grenzwerte, Streaming und Kosten für Agentenläufe
Agents machen viele Aufrufe in kurzer Zeit, daher sind die Kontingente des Kontos wichtiger als bei einem einfachen Chatbot. Ein Vollkey erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Trial-Key erlaubt 2 und 60. Wenn du mit batch auffächerst oder mehrere Agents gleichzeitig ausführst, begrenze die Parallelität in der Konfiguration:
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
)
prompts = ["Name one prime number.", "Name one even number.", "Name one square number."]
answers = llm.batch(prompts, config={"max_concurrency": 8})
for a in answers:
print(a.content)
Verwende 2 statt 8 auf dem Trial-Key. Für interaktive Agents gibt llm.stream(...) Token über SSE zurück, sobald sie generiert werden, und die Nutzungszahlen kommen am Ende des Streams an.
Die Kosten lassen sich leicht abschätzen. Ein 5-Schritte-Lauf, der im Durchschnitt 4.000 Input- und 300 Output-Token pro Schritt nutzt, verwendet insgesamt 20.000 Input- und 1.500 Output-Token, was bei $0,15 und $0,50 pro 1M Token $0,003 + $0,00075 = $0,00375 pro Lauf entspricht. Die Preisseite enthält die Sätze, und die Dokumentation listet die Anfrageparameter und Header auf, einschließlich X-Request-Id zur Nachverfolgung eines einzelnen fehlgeschlagenen Aufrufs.
Tools entwerfen, die das Modell nutzen kann
Die meisten Agentenfehler lassen sich auf die Tools zurückführen, nicht auf die Schleife. Einige Regeln helfen bei jedem Modell:
- Halte jedes Tool schmal. Ein Tool namens
get_order_statusfunktioniert besser als eines namensdatabase_query, das Freitext annimmt. - Verwende einfache Argumenttypen: Strings, Integer und kurze Enums. Tief verschachtelte Objekte geben dem Modell mehr Möglichkeiten, ein Feld falsch zu machen.
- Gib kurze, klare Ergebnisse zurück. Ein Tool, das 50.000 Zeichen in die Konversation wirft, füllt das Kontextfenster und erhöht die Kosten jedes folgenden Schritts.
- Gib Fehler als Text zurück, z. B. "order_id muss wie A100 aussehen", anstatt Ausnahmen auszulösen, die den Lauf beenden.
Teste den Agent mit einigen echten Prompts mit dem Testguthaben von $0,50, bevor du skalierst. Neue Nutzer erhalten es mit einem Klick auf der Schlüsselseite, und es ist 7 Tage gültig.
Häufige Fallstricke, die du zuerst prüfen solltest
- Tool-Aufruf erscheint nie. Mach den Docstring spezifischer, senke die Temperatur oder erzwing den Aufruf mit
tool_choice. - Ungültige Argumente. Validiere innerhalb des Tools und gib eine klare Fehlermeldung zurück, damit das Modell sich im nächsten Schritt korrigieren kann.
- Kontextwachstum. Das Kontextfenster umfasst 100.000 Token einschließlich der Antwort. Schneide alte Tool-Ausgaben ab, bevor das Fenster voll ist.
Weitere Anleitungen
Fragen und Antworten
Welche LangChain-Klasse funktioniert mit dieser API?
ChatOpenAI aus langchain-openai. Setze base_url auf https://api.unlimitedaiapi.com/v1, das Modell auf uncensored und übergebe deinen Schlüssel als api_key.
Unterstützt die API Function Calling für Agenten?
Ja. Sie akzeptiert die Parameter tools und tool_choice, gibt tool_calls zurück (auch beim Streaming) und verarbeitet Ergebnisse als Nachrichten mit der Rolle tool.
Kann LangChain strukturierte Ausgaben über diese API parsen?
Ja, über den JSON-Modus: Setze response_format auf den Typ json_object. Es garantiert gültige JSON-Syntax, also validiere die Felder selbst.
Wie viele Agenten kann ich parallel ausführen?
Ein Vollkey erlaubt 8 parallele Anfragen und 300 pro Minute. Der Trial-Key erlaubt 2 parallele und 60 pro Minute.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.