LangChain Custom LLM API: Zeige auf jede Basis-URL
Um eine langchain custom llm api zu verwenden, musst du keine benutzerdefinierte Klasse schreiben: Der OpenAI-kompatible Chat-Wrapper akzeptiert eine Basis-URL, einen Schlüssel und einen Modellnamen. Hier ist die genaue Konfiguration, plus Streaming, Tools, JSON-Ausgabe und Limit-Handling.
Wichtige Punkte
- ChatOpenAI benötigt base_url, api_key und model, daher ist keine Unterklasse erforderlich.
- Verwende das Modell uncensored und die Basis-URL https://api.llmapistatus.com/v1.
- Tool-Aufrufe, Streaming und JSON-Modus werden alle durch den Endpunkt geleitet.
- Begrenze parallele Chains auf 8, um das Concurrency-Limit einzuhalten; Embeddings werden nicht angeboten.

Die kurze Antwort: ChatOpenAI mit einer anderen Basis-URL
LangChain kommuniziert mit OpenAI-kompatiblen Servern über das langchain-openai-Paket. Seine Klasse ChatOpenAI ermöglicht es dir, den Zielort der Anfragen zu überschreiben, was genau das ist, was ein benutzerdefinierter Endpunkt benötigt. Installiere das Paket und übergebe dann drei Werte: die Basis-URL https://api.llmapistatus.com/v1, deinen Schlüssel und die Modell-ID uncensored.
Installation mit pip install -U langchain-openai langchain-core.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmapistatus.com/v1",
api_key=os.environ["LLM_API_KEY"],
temperature=0.7,
)
print(llm.invoke("Reply with the single word: ready").content)
Wenn das eine Antwort ausgibt, ist die Verbindung korrekt. Du erhältst einen Schlüssel auf der API-Schlüssel-Seite; die Schnellstartanleitung zeigt denselben Wechsel für reine SDK-Nutzer. Der Endpunkt bedient POST /v1/chat/completions und GET /v1/models, und genau diese beiden Methoden benötigt der OpenAI-Wrapper für Chat.
Ein Wort zum Begriff "custom LLM". LangChain dokumentiert auch eine Möglichkeit, ein eigenes Chat-Modell zu schreiben, indem man eine Basisklasse unterklassifiziert, was für APIs sinnvoll ist, die nicht das OpenAI-Format sprechen. Dieser Endpunkt spricht es, daher würde eine Unterklasse nur Code hinzufügen, den es zu warten gilt. Greife nur darauf zurück, wenn du Verhalten benötigst, das der Wrapper nicht ausdrücken kann.
Erstellen einer Chain mit Prompts und Ausgabe-Parsing
Sobald das Modell-Objekt steht, funktioniert alles andere in LangChain wie bei jedem anderen Chat-Modell. Hier ist eine kleine Chain im Expression-Language-Stil: eine Prompt-Vorlage, das Modell und ein String-Parser.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You are a blunt technical editor. Answer in at most {limit} words."),
("human", "Rewrite this for clarity:\n\n{text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({
"limit": 60,
"text": "The thing that we did was basically to make the cache be invalidated on write.",
}))
Nichts in dieser Chain weiß oder kümmert sich darum, dass das Modell hinter einer anderen Domäne sitzt. Das ist der Vorteil der kompatiblen API: Prompts, Memory-Klassen, Retriever und Agents, die gegen die Standard-Chat-Schnittstelle geschrieben wurden, funktionieren weiterhin. Was du auf deiner Seite prüfen solltest, ist der Prompt selbst. Ein Modell, das darauf trainiert ist, ohne Inhaltsablehnungen zu antworten, folgt Anweisungen wörtlich, daher führen vage System-Prompts zu vagem Verhalten. Definiere die Rolle, das Format und die Länge.
Eine Grenze ist es wert, dass du sie kennst, bevor du eine Retrieval-Pipeline entwirfst. Dieser Dienst ist textbasiert. Es gibt keine Embeddings, daher wird OpenAIEmbeddings, das auf diese Basis-URL zeigt, fehlschlagen. Verwende ein lokales Embedding-Modell oder einen anderen Anbieter für den Vektorspeicher und nutze diesen Endpunkt nur für die Generierung.
Streaming-Token bei Ankunft
Der Endpunkt unterstützt Server-Sent Events, wenn du stream: true sendest, und LangChain wandelt das in einen Iterator um. Du setzt das Flag nicht selbst; der Aufruf von .stream() erledigt das.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
for chunk in llm.stream("Write a four-line poem about a failing cron job."):
print(chunk.content, end="", flush=True)
print()
Für asynchrone Server verwende astream. Der gleiche Aufruf existiert in der JavaScript-Bibliothek:
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.LLM_API_KEY,
configuration: { baseURL: "https://api.llmapistatus.com/v1" },
});
const stream = await llm.stream("Write a four-line poem about a failing cron job.");
for await (const chunk of stream) {
process.stdout.write(chunk.content);
}
Denke daran, dass eine gestreamte Anfrage ihren Concurrency-Slot bis zum letzten Ereignis belegt. Wenn ein Benutzer den Browsertab schließt und dein Server den Stream weiter liest, bleibt dieser Slot belegt. Brich die Upstream-Anfrage ab, wenn der Client die Verbindung trennt. Nutzungszahlen kommen am Ende des Streams an, wo du die endgültigen Token-Anzahlen für Abrechnungsprotokolle liest.
Tool Calling und Agents
Tool Calling ist verfügbar: Der Endpunkt akzeptiert tools und tool_choice, streamt tool_calls zurück und verarbeitet deine Ergebnisse als Nachrichten mit role: "tool". In LangChain bindest du Tools mit bind_tools an und lässt das Framework die Nachrichten aufbauen.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.tools import tool
@tool
def get_order_status(order_id: str) -> str:
'Look up the status of an order by its id.'
return f"Order {order_id} shipped yesterday."
llm_tools = llm.bind_tools([get_order_status])
ai = llm_tools.invoke("Where is order A-1042?")
print(ai.tool_calls)
Das Ausführen des Aufrufs und Zurückgeben des Ergebnisses ist die zweite Hälfte der Schleife:
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
# llm_tools comes from the previous snippet
from langchain_core.messages import HumanMessage, ToolMessage
messages = [HumanMessage("Where is order A-1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)
for call in ai.tool_calls:
result = get_order_status.invoke(call["args"])
messages.append(ToolMessage(content=result, tool_call_id=call["id"]))
print(llm_tools.invoke(messages).content)
Open-Weight-Modelle variieren darin, wie gut sie Tools auswählen und Argumente füllen. Halte Tool-Beschreibungen kurz und konkret, verwende wenige Tools pro Aufruf und validiere Argumente in deiner Funktion, anstatt ihnen zu vertrauen. Wenn ein Agent in einer Schleife landet, senke die Temperatur und setze eine maximale Anzahl von Schritten in deinem Agent-Executor.
Strukturierte und JSON-Ausgabe
JSON-Modus wird über response_format: {"type": "json_object"} unterstützt. In LangChain ist der einfachste Weg with_structured_output unter Verwendung der JSON-Modus-Methode, die das Ergebnis auch gegen ein Schema validiert.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from pydantic import BaseModel
class Ticket(BaseModel):
title: str
priority: str
tags: list[str]
structured = llm.with_structured_output(Ticket, method="json_mode")
result = structured.invoke(
"Return JSON with keys title, priority and tags for this report: "
"login page times out on mobile, affects many users."
)
print(result)
JSON-Modus garantiert, dass die Ausgabe ein JSON-Objekt ist, nicht dass sie die gewünschten Felder hat. Zwei Gewohnheiten helfen. Erstens: Benenne die Schlüssel im Prompt, wie oben; die Anweisung zur Erzeugung von JSON sollte explizit sein. Zweitens: Packe den Aufruf in eine Wiederholung, die bei einem Fehler erneut parst. Die Pydantic-Prüfung fängt fehlende Felder und falsche Typen ab, und eine einzelne Wiederholung mit angehängter Fehlermeldung behebt dies normalerweise.
Du kannst response_format auch direkt setzen, wenn du das Modell mit model_kwargs={"response_format": {"type": "json_object"}} erstellst, was praktisch für reine Chains ist, die in einem JSON-Parser enden.
Ratenlimits, Wiederholungen und parallele Chains
Batch-Jobs und Agents stellen viele Aufrufe gleichzeitig, und hier unterscheidet sich ein benutzerdefinierter Endpunkt von einem lokalen Modell. Ein vollständiger Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Ein Test-Schlüssel erlaubt 2 parallele und 60 pro Minute. Nach Überschreiten einer Grenze antwortet die API mit HTTP 429 und dem Fehlercode rate_limited oder concurrency; bei temporärer Überlastung antwortet sie mit 429 und Retry-After: 5.
Zwei LangChain-Einstellungen regeln den Großteil davon. Das Modell nimmt max_retries entgegen, das bei vorübergehenden Fehlern mit Backoff wiederholt, und Runnables akzeptieren einen max_concurrency-Wert in ihrer Konfiguration für Batch-Arbeit:
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmapistatus.com/v1",
api_key=os.environ["LLM_API_KEY"],
max_retries=4,
timeout=120,
)
questions = [f"Summarise item {i} in one sentence." for i in range(40)]
answers = llm.batch(questions, config={"max_concurrency": 6})
Das Setzen der Obergrenze auf 6 bei einem vollständigen Schlüssel lässt Raum für zwei weitere Anfragen, etwa eine benutzerseitige Anfrage derselben App. Verwende bei einem Test-Schlüssel 1 oder 2. Verlasse dich nicht allein auf Wiederholungen bei einem Parallelitätsproblem: Wenn die Obergrenze über der Grenze liegt, erzeugen Wiederholungen nur dieselbe Kollision erneut. Das Auslesen von X-RateLimit-Limit-Requests und X-RateLimit-Limit-Concurrency aus den Antwort-Headern zeigt dir, was dein Schlüssel erlaubt.
Lange Eingaben sind bis zum 100.000-Token-Fenster in Ordnung, das zwischen Prompt und Completion geteilt wird, und der Request-Body ist auf 8 MB begrenzt. LangChain-Text-Splitter, die auf einige tausend Token pro Chunk eingestellt sind, halten dich weit von beiden entfernt.
Fehlerbehebung eines benutzerdefinierten Endpunkts
Die meisten Probleme mit einer benutzerdefinierten Basis-URL fallen in eine kurze Liste, und jeder Punkt hat einen schnellen Test.
- Authentifizierungsfehler. LangChain liest auch die Umgebungsvariable
OPENAI_API_KEY. Wenn duapi_keyexplizit übergibst, hat dieser Wert Vorrang, aber eine veraltete Variable kann dennoch ein zweites Modell-Objekt verwirren, das du vergessen hast zu konfigurieren. Übergebe den Schlüssel jedes Mal und gib der Variable einen anderen Namen, wie z. B.LLM_API_KEY. - Nicht-Gefunden-Fehler. Die Basis-URL muss mit
/v1enden. LangChain hängt/chat/completionsselbst an, sodass das Hinzufügen zur Basis-URL einen doppelten Pfad erzeugt. - Unbekanntes Modell. Frage
GET /v1/modelsmit demselben Schlüssel ab und kopiere die ID, die es ausgibt. Sie sollteuncensoredsein. - Stille Hänger in langen Chains. Setze
timeoutauf dem Modell und logge den Antwort-HeaderX-Request-Id. Wenn du den Support kontaktierst, ermöglicht diese ID ihnen, die genaue Anfrage zu finden. - Überraschende Ausgaben. Gib den finalen Prompt aus, bevor er gesendet wird. Die meisten seltsamen Antworten in LangChain stammen von einer Vorlage, die eine Variable mit etwas Unerwartetem gefüllt hat, nicht vom Modell.
Im Zweifelsfall reproduziere den fehlerhaften Aufruf mit einem einfachen curl gegen dieselbe URL. Wenn curl funktioniert und LangChain nicht, liegt der Fehler in deiner Chain; wenn beide fehlschlagen, prüfe den Schlüssel und das Guthaben.
Kosten während des Baus prüfen
Chains verbergen Token-Anzahlen, also messe früh. Jede Antwort enthält Nutzungsinformationen, und die Antwort-Header enthalten X-Balance-USD. Der Preis beträgt $0,15 pro 1M Input-Token und $0,50 pro 1M Output-Token, abgerechnet vom Prepaid-Guthaben.
Ein durchgearbeitetes Beispiel: Eine Retrieval-Chain, die 6.000 Token Kontext und Frage sendet und 400 Token zurückbekommt, kostet 6.000 x $0,15 / 1M = $0,0009 für Input plus 400 x $0,50 / 1M = $0,0002 für Output, also $0,0011 pro Aufruf. Das Ausführen von 5.000 solcher Aufrufe in einem Test-Durchlauf kostet $5,50. Das ist nützlich zu wissen, bevor du eine Agent-Schleife über Nacht laufen lässt.
Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet. Die Preisseite listet Aufladebeträge von $20 bis $500 mit Boni auf, und neue Konten können mit einem Klick ein $0,50 kostenloses Testguthaben beanspruchen, das für einige hundert kleine Testaufrufe ausreicht, während du die Integration einrichtest.
Weitere Anleitungen
Fragen und Antworten
Muss ich die Basisklasse für Chat-Modelle von LangChain unterklassifizieren?
Nein. Der Endpunkt ist OpenAI-kompatibel, daher funktionieren ChatOpenAI mit einer benutzerdefinierten base_url, api_key und Modell. Das Unterklassifizieren ist nur für APIs erforderlich, die ein anderes Format verwenden.
Kann ich OpenAIEmbeddings mit diesem Endpunkt verwenden?
Nein. Der Dienst ist nur textbasiert und bietet keine Embeddings. Verwende ein lokales Embedding-Modell oder einen anderen Anbieter für Vektoren und diesen Endpunkt für die Generierung.
Welchen Modellnamen gebe ich an?
Gib uncensored als Modell an. GET /v1/models gibt dieselbe ID zurück.
Warum erhalte ich 429-Fehler in einem Batch-Job?
Du hast entweder das Ratenlimit pro Minute oder parallele Anfragen überschritten. Reduziere max_concurrency auf einem Voll-Key auf unter 8, bei einem Trial-Key auf 2, und aktiviere Retries.
Funktioniert das Streaming von LangChain hier?
Ja. Das Aufrufen von stream oder astream nutzt Server-Sent Events, und die Nutzungsinformationen werden am Ende des Streams gesendet.
Dein Schlüssel ist nur ein Formular entfernt
Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.