Wichtige Punkte
- ChatOpenAI benötigt base_url, api_key und model, daher funktioniert jeder OpenAI-kompatible Endpunkt.
- Nutze die Basis-URL https://api.uncensoredllmhub.com/v1 und das Modell uncensored.
- Tool Calling wird unterstützt; für strukturierte Ausgaben ist der JSON-Modus die sicherste Methode.
- Achte auf Limits: 8 gleichzeitige Anfragen bei einem Voll-Key, also begrenze deine Batch-Parallelität.
Installieren und verbinden
LangChains OpenAI-Integration ist ein separates Paket zur Kernbibliothek. Installiere es mit pip install langchain-openai. Hol dir einen Schlüssel von der API-Schlüssel-Seite; neue Nutzer können dort mit einem Klick $0,50 an Testguthaben beanspruchen, keine Karte nötig.
Erstelle dann das Modell-Objekt. Drei Argumente sind wichtig: model, base_url und api_key.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredllmhub.com/v1",
api_key="YOUR_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a lighthouse cat.").content)Das ist die gesamte Integration. Alles nachgelagerte, wie Prompts, Parser, Agenten und Retriever, behandelt llm wie jedes andere Chat-Modell. Wenn du Umgebungsvariablen bevorzugst, liest das OpenAI SDK OPENAI_API_KEY und OPENAI_BASE_URL, was den Wechsel zwischen Umgebungen ohne Codeänderungen einfach macht.
Was der Endpunkt unterstützt
Der Dienst stellt POST /v1/chat/completions, POST /v1/responses und GET /v1/models bereit. ChatOpenAI nutzt standardmäßig Chat Completions, was die sichere Wahl ist. Das Modell ist ein Open-Weight-Modell, das darauf abgestimmt ist, ohne Inhaltsablehnungen für die rechtmäßige Nutzung durch Erwachsene zu antworten, mit einem 100.000-Token-Kontextfenster, das sich Prompt und Completion teilen.
Unterstützte Anfrage-Features, auf die LangChain zurückgreift: Streaming über SSE mit Nutzung am Ende, Function Calling, JSON-Modus und die Sampling-Parameter temperature, top_p, stop, seed und die Penalties. Nicht verfügbar: Embeddings, Bild- oder Audio-Generierung, Fine-Tuning. Wenn eine Retrieval-Kette Embeddings benötigt, verwende für diesen Schritt ein anderes Embedding-Modell und behalte diesen Endpunkt für die Generierung. Vollständige Parameterhinweise findest du in der Dokumentation.
Ein Prompt, ein Modell und ein Parser
Das grundlegende LCEL-Muster leitet einen Prompt in das Modell und dann in einen Output-Parser. Streaming kommt mit .stream() kostenlos dazu.
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You are a concise editor. Reply in {tone} tone."),
("human", "Improve this sentence: {text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "plain", "text": "The thing was done by the team."}))
for piece in chain.stream({"tone": "friendly", "text": "We regret to inform you of a delay."}):
print(piece, end="", flush=True)Die System-Nachricht legt das Verhalten für jeden Aufruf fest. Da das Kontextfenster groß ist, kannst du in vielen Fällen auch langen Referenztext über die Prompt-Vorlage ohne Splitter füttern. Die Eingabekosten betragen $0,15 pro 1 Mio. Token, also kostet ein 20.000-Token-Dokument im Prompt 20.000 / 1.000.000 x $0,15 = $0,003 pro Aufruf.
Function Calling
Tool Calling folgt dem OpenAI-Format: Du übergibst Funktionsdefinitionen, das Modell antwortet mit tool_calls, du führst die Funktion aus und sendest das Ergebnis als Nachricht mit der tool-Rolle zurück. LangChain packt dies in bind_tools.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def add(a: int, b: int) -> int:
"""Add two integers."""
return a + b
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([add])
msg = llm_tools.invoke("What is 41 plus 1? Use the tool.")
for call in msg.tool_calls:
print(call["name"], call["args"]) # run the function yourself, then send a ToolMessage backDas Modell fordert den Aufruf an; dein Code führt ihn aus. In einem Agenten-Framework wie LangGraph übernimmt eine Schleife dies für dich, bis das Modell in Klartext antwortet. Halte Tool-Beschreibungen kurz und Argumentnamen einfach. Wenn das Modell ein Tool ignoriert, verschärfe die Docstring und setze tool_choice, um den Aufruf während der Fehlersuche zu erzwingen.
Strukturierte Ausgabe mit JSON-Modus
Der Endpunkt unterstützt den JSON-Modus, response_format: {"type":"json_object"}. Frag in LangChain darüber mit with_structured_output und wähle die JSON-Modus-Methode, validiere dann mit einem Pydantic-Modell.
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
class Ticket(BaseModel):
title: str
priority: str
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
structured = llm.with_structured_output(Ticket, method="json_mode")
print(structured.invoke("Return JSON with title and priority for: login page crashes on Safari, urgent."))Zwei Gewohnheiten machen JSON zuverlässig. Erstens: Schreibe „JSON“ und benenne die Schlüssel im Prompt, da der JSON-Modus gültige Syntax garantiert, aber nicht dein Schema. Zweitens: Packe den Aufruf in eine Wiederholung, die Validierungsfehler abfängt und den Fehlertext einmal an das Modell zurücksendet. Verlasse dich nicht auf Decoding mit Schemaeinschränkung, es sei denn, du hast es mit diesem Endpunkt getestet.
Parallelität, Wiederholungen und Kostenkontrolle
LangChain macht parallele Aufrufe einfach mit .batch(), und genau dort greifen die Limits. Ein Voll-Key erlaubt 8 gleichzeitige Anfragen und 300 pro Minute. Ein Trial-Key erlaubt 2 und 60. Übergebe config={"max_concurrency": 6} an batch, damit du unter der Grenze bleibst.
Wenn das Limit überschritten wird, gibt die API HTTP 429 mit dem Code rate_limited oder concurrency und einen Retry-After: 5-Header bei temporärer Überlastung zurück. ChatOpenAI hat ein Argument max_retries, das dies mit Backoff behandelt; setze es auf 3 bis 5. Streams belegen einen Slot bis zum Abschluss, also lasse keine halb gelesenen Streams offen.
Durchgerechnetes Kostenbeispiel: Ein Batch-Job mit 2.000 Elementen, jedes mit 800 Eingabe-Token und 150 Ausgabe-Token. Eingabe: 2.000 x 800 = 1.600.000 Token = 1,6 x $0,15 = $0,24. Ausgabe: 2.000 x 150 = 300.000 Token = 0,3 x $0,50 = $0,15. Der Job kostet $0,39. Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, und der X-Balance-USD-Header lässt dich deinen Saldo beobachten. Sieh dir die Preise für Aufladungen an, die von $20 bis $500 reichen und mit Krypto bezahlt werden können.
Agenten und Gesprächsspeicher
Zwei Muster tauchen direkt auf, nachdem die erste Kette funktioniert. Das erste ist der Gesprächsspeicher. LangChains Message-History-Helfer speichern vergangene Turns und hängen sie jedem Aufruf voran. Da das Fenster 100.000 Token hat, kannst du lange Historien behalten, aber bedenke, dass jeder Turn sie erneut sendet. Eine 30.000-Token-Historie bei 50 Turns bedeutet 1.500.000 Eingabe-Token, oder 1,5 x $0,15 = $0,225 für die Sitzung. Das Zusammenfassen alter Turns, sobald die Historie ein Größenlimit überschreitet, hält das flach.
Das zweite ist die Agenten-Schleife. In LangGraph übernimmt ein vorgefertigter Agent dasselbe llm-Objekt plus eine Liste von Tools und läuft, bis das Modell aufhört, Tools anzufordern. Setze eine maximale Anzahl an Schritten, damit eine verwirrte Schleife keine Eingabe-Token aufbläht. Logge den X-Request-Id-Antwortheader für jeden Aufruf, der sich seltsam verhält, da dies die Kennung ist, die du bei der Kontaktaufnahme mit dem Support angeben musst.
Fehlerbehebung
- 404 bei jedem Aufruf. Die Basis-URL muss mit
/v1enden und darf nicht/chat/completionsenthalten. - Modell nicht gefunden. Nutze
uncensoredexakt. LangChain validiert Modellnamen für benutzerdefinierte Endpunkte nicht. - Token-Zählwarnungen. Einige LangChain-Funktionen schätzen Token mit OpenAI-Tokenizern. Die Zählwerte können leicht vom echten Modell abweichen, also verlasse dich auf die Nutzung, die die API zurückgibt.
- Lange Agent-Schleifen sind teuer. Jede Schleife sendet die vollständige Historie neu. Kürze alte Tool-Ausgaben vor der nächsten Anfrage.
Wenn deine Kette korrekt aussieht, aber dennoch fehlschlägt, rufe den Endpunkt mit einfachem curl auf, um ein LangChain-Problem von einem Konto-Problem zu trennen.

