Lokal oder gehostet: Wähle nach dem Engpass
Nutzer, die nach LangChain mit einem lokalen Modell suchen, wollen meist eines von drei Dingen: Datenschutz, keine Token-Abrechnung oder Unabhängigkeit von einem Anbieter. Ein Modell auf deiner eigenen Maschine, bereitgestellt mit Tools wie Ollama oder llama.cpp, liefert alle drei, wenn du Hardware hast, die es mit nutzbarer Geschwindigkeit ausführen kann. Der Nachteil ist der Setup-Aufwand, Speicherlimits und die Geschwindigkeit deiner GPU oder CPU.
Ein gehosteter Endpunkt tauscht das gegen geringe Nutzungskosten ein. Du sendest Prompts über das Netzwerk, und das Modell läuft auf der Hardware eines anderen. Das bedeutet hier ein Open-Weight-Modell, das darauf abgestimmt ist, ohne Inhaltsfilter für die rechtmäßige Nutzung durch Erwachsene zu antworten, bereitgestellt über eine OpenAI-kompatible API. Prompts werden nicht zum Training verwendet, verlassen aber deinen Rechner. Ein gehosteter Dienst ist also die falsche Wahl, wenn deine Regel lautet, dass Daten ihn niemals verlassen dürfen.
Der nützliche Teil für einen LangChain-Entwickler ist, dass sich der Code kaum unterscheidet. Lokale Server wie Ollama und llama.cpp bieten OpenAI-ähnliche Endpunkte, und ein gehosteter Endpunkt spricht das gleiche Protokoll. Wenn du deine App gegen ChatOpenAI mit einer konfigurierbaren Base URL schreibst, kannst du lokal entwickeln und mit einer Umgebungsvariable zu einem gehosteten Modell wechseln. Das bietet dir eine praktische Hybrid-Lösung: Iteriere mit einem kleinen lokalen Modell und nutze das Gehostete, wenn du das Verhalten eines größeren Modells willst, ohne die GPU zu besitzen.
Verbinde ChatOpenAI mit dem Endpunkt
Installiere das Integrationspaket und erstelle dann das Modellobjekt mit den drei wichtigen Einstellungen.
pip install langchain-openai langchain-core
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmproxyapi.com/v1",
api_key=os.environ["LLMPROXY_API_KEY"],
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
Wenn das funktioniert, läuft alles andere genauso. Hol dir deinen Schlüssel auf der API-Schlüssel-Seite; neue Nutzer können dort nach der Anmeldung mit einem Klick $0,50 an kostenloses Testguthaben beanspruchen, keine Karte nötig. Gib die Base URL explizit im Code an, statt dich auf eine Umgebungsvariable zu verlassen, da verschiedene Bibliotheks-Versionen unterschiedliche Variablennamen lesen und ein stilles Fallback auf den Standard-OpenAI-Host deinen Schlüssel an die falsche Stelle sendet.
Der Modellname ist die Stelle, an der die meisten stolpern. Die einzige ID hier ist uncensored. Ein Name wie llama3 oder gpt-4o wird nicht erkannt.
Eine Chain mit einer Prompt-Vorlage
Die Standard-Pipeline aus Prompt, Modell und Output-Parser läuft unverändert. Dieses Beispiel fasst Text in einem gewählten Ton zusammen.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You are a writing assistant. Answer in a {tone} tone."),
("human", "Summarize in two sentences:\n\n{text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "dry", "text": "Long article text goes here..."}))
Nutze für viele Eingaben batch und begrenze die Parallelität. Ein Voll-Key erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute, also halte die Einstellung bei 8 oder darunter:
results = chain.batch(
[{"tone": "dry", "text": t} for t in documents],
config={"max_concurrency": 6},
)
Ein Trial-Key erlaubt nur 2 parallele Anfragen und 60 pro Minute, also nutze max_concurrency mit 2 beim Testen.
Streaming
Die API streamt über Server-Sent Events, und LangChain stellt dies über stream zur Verfügung. Nutze es für Chat-Oberflächen, in denen eine Person die Antwort entstehen sieht.
for chunk in llm.stream("Write a short scene set in a lighthouse."):
print(chunk.content, end="", flush=True)
Ein praktisches Detail: Eine gestreamte Anfrage behält ihren Parallelitäts-Slot, bis der Stream endet. Wenn deine UI einen Stream mittendrin verlässt, stelle sicher, dass der Generator geschlossen wird, sonst schrumpft dein Parallelitäts-Puffer. Asynchroner Code verwendet auf die gleiche Weise astream.
Tools und Agenten
Tool Calling wird unterstützt: Die API akzeptiert tools und tool_choice, streamt tool_calls und nimmt Ergebnisse als role: "tool"-Nachrichten entgegen. LangChain packt dies in bind_tools.
from langchain_core.tools import tool
@tool
def dice(sides: int) -> int:
"Roll a die with the given number of sides."
import random
return random.randint(1, sides)
llm_tools = llm.bind_tools([dice])
msg = llm_tools.invoke("Roll a twenty-sided die for the goblin attack.")
print(msg.tool_calls)
Das Ergebnis listet die Aufrufe auf, die das Modell möchte, mit Namen und Argumenten. Führe sie aus, hänge die Ergebnisse als Tool-Nachrichten an und rufe das Modell erneut auf, oder lass ein Agenten-Framework wie LangGraph diese Schleife ausführen. Agenten führen viele Aufrufe pro Benutzeranfrage aus, daher erreichen sie das pro Minute geltende Limit früher als einfache Chains. Zähle Aufrufe pro Lauf, bevor du ein Concurrency-Level wählst.
Das Kontextfenster umfasst 100.000 Token für Prompt plus Completion, was großzügig für Gesprächsspeicher ist. Schneide dennoch alte Turns ab: Du zahlst für die gesamte Historie bei jedem Aufruf mit $0,15 pro 1 Mio. Input-Token.
JSON-Ausgabe
Der JSON-Modus ist über response_format verfügbar. In LangChain kannst du ihn mit model_kwargs übergeben oder den Structured-Output-Helper im JSON-Modus nutzen und die Felder in deinem Prompt beschreiben.
from pydantic import BaseModel
class Character(BaseModel):
name: str
role: str
secret: str
structured = llm.with_structured_output(Character, method="json_mode")
out = structured.invoke(
"Invent a character for a mystery story. Reply in JSON with keys name, role, secret."
)
print(out)
Mit method="json_mode" muss das Prompt dem Modell mitteilen, welche Keys es erzeugen soll; die Pydantic-Klasse validiert dann das geparste Ergebnis. Halte eine Retry-Logik bereit, falls mal eine fehlerhafte Antwort kommt.
Was nicht übernommen wird
Zwei LangChain-Standards benötigen eine andere Quelle. Die API hat keinen Embeddings-Endpunkt, daher wird OpenAIEmbeddings, das hierher zeigt, fehlschlagen. Für Retrieval über deine Dokumente verwende ein lokales Embedding-Modell oder einen anderen Embedding-Anbieter und nutze diesen Endpunkt nur für den Chat-Schritt. Es gibt auch keine Bild-Eingabe oder -Generierung, kein Audio und kein Fine-Tuning, daher sind Vision Chains und multimodale Loader nicht dabei.
Die Fehlerbehandlung betrifft hauptsächlich 429-Antworten. Der Code rate_limited bedeutet, dass du das pro Minute geltende Limit überschritten hast, concurrency bedeutet zu viele parallele Aufrufe, und eine 429 mit Retry-After: 5 kennzeichnet eine temporäre Überlastung. Setze max_retries auf ChatOpenAI, damit der Client wartet und wiederholt. Fehlgeschlagene und abgelehnte Anfragen werden nicht berechnet.
Die Response-Header helfen beim Monitoring: X-Balance-USD zeigt dein verbliebenes Guthaben an und X-Request-Id identifiziert eine Anfrage für den Support.
Zwischen lokal und gehostet mit einer Variable wechseln
Wenn du die Hybrid-Lösung willst, lege die drei Einstellungen in Umgebungsvariablen und erstelle das Modell in einer Funktion. Deine Chains importieren diese Funktion und erwähnen keinen Anbieter.
import os
from langchain_openai import ChatOpenAI
def make_llm():
if os.environ.get("LLM_MODE") == "local":
return ChatOpenAI(
model=os.environ["LOCAL_MODEL"],
base_url="http://localhost:11434/v1",
api_key="not-needed",
)
return ChatOpenAI(
model="uncensored",
base_url="https://api.llmproxyapi.com/v1",
api_key=os.environ["LLMPROXY_API_KEY"],
)
Der lokale Branch geht von einem Ollama-Server auf seinem Standardport aus, der eine OpenAI-kompatible Route unter /v1 bereitstellt; prüfe die Dokumentation deines eigenen Servers für die richtige Adresse und den Modellnamen. Das Verhalten wird zwischen Modellen variieren, also führe deine Prompts nach einem Wechsel erneut aus. Ein Prompt, das auf die Gewohnheiten eines Modells abgestimmt ist, kann sich bei einem anderen anders verhalten, und die Qualität des Tool Calling variiert je nach Modell, also teste diese Pfade zuerst.
Ein sinnvoller Workflow ist, Prompts gegen das gehostete Modell zu entwickeln, während du keine GPU frei hast, und dann zu entscheiden, welche Teile der App auf deiner eigenen Maschine bleiben müssen. Sensible Dokumente können den lokalen Zweig nutzen, und öffentlich zugängliche kreative Funktionen das Gehostete.
Kosten und nächste Schritte
Die Preise betragen $0,15 pro 1 Mio. Input-Token und $0,50 pro 1 Mio. Output-Token, bezahlt aus Prepaid-Guthaben ohne Abonnement. Ein Chain Call mit 2.000 Input-Token und 500 Output-Token kostet 2.000 × $0,15 / 1 Mio. + 500 × $0,50 / 1 Mio. = $0,0003 + $0,00025 = $0,00055. Tausend solcher Calls kosten $0,55. Aufladungen sind von $20 bis $500 per Krypto (USDT auf TRC20, USDC auf Base) möglich, mit einem Bonus von 5 % ab $50, 10 % ab $100 und 15 % ab $200. Details findest du auf der Preisseite.
Für eine Plain-HTTP-Ansicht derselben API lies die Schnellstart-Anleitung. Die Seite hat außerdem eine kurze Übersicht zum Pay-as-you-go-Service.
