Verbinde LangChain in vier Zeilen
Wenn du LangChain Open-Source-Modelle nutzen möchtest, ohne etwas zu hosten, ist der kürzeste Weg eine OpenAI-kompatible API. Die OpenAI-Chat-Klasse von LangChain ist es egal, wer antwortet, solange der Endpunkt das gleiche Protokoll spricht. Du änderst die base_url und den Schlüssel, und der Rest deiner Chains, Prompts und Agents bleibt unverändert.
Dieser Dienst hostet ein Open-Weight-Modell, betrieben von einem unabhängigen Anbieter und optimiert für Antworten ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene. Es ist nicht die offizielle API eines Modell-Anbieters und kein Router über Anbieter hinweg. Installiere das Paket und erstelle das Modell-Objekt:
pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
Das ist die gesamte Verbindung. Halte den Schlüssel in echten Projekten in einer Umgebungsvariable und lies ihn mit os.environ aus, statt ihn in die Datei zu schreiben. Wenn du noch keinen Schlüssel hast, zeigt die Schlüsselseite, wie du dich anmeldest und $0,50 kostenloses Testguthaben erhältst, ohne dass eine Karte benötigt wird.
Node.js und LangChain.js
Das JavaScript-Paket folgt der gleichen Idee, wobei die base_url über ein Konfigurationsobjekt übergeben wird.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.API_KEY,
temperature: 0.7,
configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});
const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);
Wenn du einen 404-Fehler oder eine HTML-Seite siehst, ist die base_url meist falsch. Sie muss mit /v1 enden. Die beiden Endpunkte im Hintergrund sind POST /v1/chat/completions und GET /v1/models, und nichts anderes wird für das Chat-Modell von LangChain benötigt.
Ist ein Open-Source-Modell in LangChain besser gehostet oder lokal?
LangChain kann auch Open-Weight-Modelle auf deiner eigenen Maschine ausführen, zum Beispiel über Ollama oder einen lokalen Server. Dieser Weg hat echte Vorteile, und es ist ehrlich, das zu sagen. Lokale Modelle haben keine Token-Gebühren, funktionieren offline und halten jedes Byte auf deiner Hardware. Der Preis ist Hardware: Du brauchst genug GPU-Speicher für das gewählte Modell, du pflegst die Laufzeit, und der Durchsatz ist durch deine Maschine begrenzt.
| Frage | Lokaler Server | Diese gehostete API |
|---|---|---|
| Vorabkosten | Hardware oder eine gemietete GPU | Keine; Prepaid-Guthaben ab $20 |
| Token-Kosten | Keine, aber Strom und Hardware-Verschleiß | $0,15 pro 1M Input, $0,50 pro 1M Output |
| Kontextfenster | Abhängig vom verfügbaren Speicher | 100.000 Token |
| Parallelität | Abhängig von deiner Einrichtung | 8 bei einem Voll-Key |
| Datenstandort | Deine Maschine | Gehostet; Prompts werden nicht zum Training verwendet |
Ein gängiges Muster ist, gegen den gehosteten Endpunkt zu prototypen und dann anhand echter Token-Anzahlen zu entscheiden, ob eine lokale Bereitstellung sinnvoll ist. Da beide Seiten das OpenAI-Protokoll sprechen, ist das Wechseln eine einzeilige Änderung an base_url, und die von dir gebauten Chains bleiben unberührt. Die Seite zu was ein unzensiertes Modell ist erklärt, was die Feinabstimmung am Verhalten ändert.
Tools und ein einfacher Agent
Tool Calling geht über das normale OpenAI-Style-tools-Feld, und bind_tools von LangChain baut das für dich aus einer dekorierten Python-Funktion. Das Modell gibt Tool-Aufruf-Anfragen zurück, und Ergebnisse gehen als role: "tool"-Nachrichten zurück.
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
@tool
def word_count(text: str) -> int:
'''Count the words in a piece of text.'''
return len(text.split())
agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)
Die Agent-Schleife ruft das Modell auf, führt das Tool bei Bedarf aus und sendet die Ausgabe zurück, bis das Modell in Klartext antwortet. Zwei Warnungen gelten. Gib jedem Tool einen Docstring, der für das Modell geschrieben ist, weil dieser Text es liest, um ein Tool auszuwählen. Und setze eine Rekursionsgrenze für Agents, damit ein verwirrter Durchlauf nicht weiter Kredit verbraucht; LangGraph akzeptiert recursion_limit in der Konfiguration.
Für direkte Kontrolle ohne Agent verwende llm.bind_tools([word_count]) und prüfe .tool_calls in der zurückgegebenen Nachricht selbst.
Strukturierte Ausgabe mit JSON-Modus
Für Extraktionsaufgaben gib den JSON-Modus-Parameter über bind weiter. Der Prompt muss dem Modell mitteilen, welche Schlüssel du willst, da JSON-Modus es nur dazu bringt, ein gültiges JSON-Objekt zu produzieren.
import json
from langchain_core.prompts import ChatPromptTemplate
json_llm = llm.bind(response_format={"type": "json_object"})
prompt = ChatPromptTemplate.from_messages([
("system", "Return a JSON object with keys title, genre and summary."),
("human", "{idea}"),
])
chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)
Validiere das Ergebnis mit Pydantic oder einer einfachen Schlüsselprüfung, bevor du es nutzt. Der Modus erzwingt kein Schema, daher ist ein fehlendes Feld möglich, und ein Retry mit einem klareren Prompt behebt das meist.
Streaming und Concurrency
Streaming läuft über Server-Sent Events und funktioniert mit der Standard-stream-Methode. Die Nutzung wird am Ende des Streams gesendet.
for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
print(chunk.content, end="", flush=True)
Wenn du viele Elemente verarbeitest, führt batch sie parallel aus, und hier zählen die Limits. Ein Voll-Key erlaubt 8 gleichzeitige Anfragen und 300 Anfragen pro Minute. Ein Trial-Key erlaubt 2 und 60. Eine gestreamte Anfrage belegt ihren Slot, bis der Stream endet. Gib einen Cap an, damit LangChain nie das überschreitet, was dein Key erlaubt:
prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})
Wenn du immer noch HTTP 429 siehst, sagt der Fehlercode, welches Limit du getroffen hast: rate_limited für Anfragen pro Minute, concurrency für zu viele gleichzeitig. Ein 429 mit einem Retry-After: 5-Header markiert temporäre Überlastung. ChatOpenAI hat eine max_retries-Option, die bei solchen Fehlern mit Backoff wiederholt; setze sie auf 3 oder 4 für Batch-Jobs.
Eine Retrieval-Kette ohne Embedding-Endpunkt
Diese API deckt nur Generierung ab, daher braucht eine Retrieval-Kette zwei Anbieter: einen für Embeddings und einen für den Chat-Schritt. LangChain macht das einfach, da der Vector Store und das Chat-Modell separate Objekte sind. Nutze jedes Embedding-Modell, das du magst, aus einer lokalen Bibliothek oder einem anderen Dienst, um deine Dokumente zu indizieren. Gib dann den abgerufenen Text über den Prompt an das Chat-Modell weiter.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
("human", "{question}"),
])
chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})
Hier ist top_chunks das, was dein Retriever zurückgegeben hat. Beschränke es auf die wenigen Passagen, die wichtig sind. Vier Chunks mit 300 Token fügen 1.200 Token pro Aufruf hinzu, was in Ordnung ist, aber vierzig Chunks fügen 12.000 hinzu und machen jede Anfrage zehnmal schwerer.
Fehlerbehebungs-Checkliste
- Authentifizierungsfehler: bestätige, dass der Schlüssel in
api_keysteht, nicht in einem anderen Parameter, und dass keineOPENAI_API_KEY-Umgebungsvariable stillschweigend überschreibt, was du übergeben wolltest. - Modell nicht gefunden: die Modell-ID ist genau
uncensored. RufeGET /v1/modelsauf, um zu sehen, was der Server auflistet. - Seltsame Tool-Argumente: lies den rohen Argumenten-String, verschärfe die Tool-Beschreibung und senke die Temperatur auf etwa 0,2 für Agent-Durchläufe.
- Tracing und Debugging: aktiviere den verbose- oder Debug-Modus lokal, um jeden ausgehenden Prompt und jede eingehende Antwort zu sehen.
- Reproduzierbare Tests: gib
seedund eine niedrige Temperatur an, wenn du Prompt-Versionen vergleichst, damit Unterschiede von deiner Änderung stammen und nicht vom Zufall.
Kosten einer LangChain-Arbeitslast
Die Abrechnung erfolgt pro Token vom Prepaid-Guthaben. Es gibt kein Abonnement, fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, und Guthaben verfällt nie. Aufladungen sind beliebige ganze Beträge von $20 bis $500, per Krypto (USDT auf TRC20, USDC auf Base), mit einem Bonus von 5 % ab $50, 10 % ab $100 und 15 % ab $200. Die Preisseite enthält die Details.
Rechne ein Beispiel durch. Ein Support-Bot beantwortet 2.000 Fragen an einem Tag. Jede Anfrage sendet etwa 1.500 Token (System-Prompt, abgerufene Snippets, Frage) und gibt etwa 250 Token zurück.
- Input: 2.000 x 1.500 = 3.000.000 Token, also 3 x $0,15 = $0,45.
- Output: 2.000 x 250 = 500.000 Token, also 0,5 x $0,50 = $0,25.
- Gesamt: $0,70 pro Tag für 2.000 Antworten, oder $0,00035 pro Antwort.
Retrieval-Chains sind der Ort, an dem die Kosten entgleisen können, da jeder zusätzliche abgerufene Chunk Eingabe-Token zu jeder Anfrage hinzufügt. Logge usage_metadata aus den Antworten, beobachte die durchschnittliche Prompt-Größe und reduziere die Chunk-Anzahl, bevor du skalierst. Die API-Dokumentation listet alle unterstützten Parameter auf, falls du weitergehen möchtest.
