Lokaal of gehost: kies op basis van de beperking die het meest restrictief is
Mensen die zoeken naar LangChain met een lokaal model willen meestal een van drie dingen: privacy, geen kosten per token, of onafhankelijkheid van een leverancier. Een model op je eigen machine, geserveerd door een tool zoals Ollama of llama.cpp, levert alle drie op als je hardware hebt die het met een bruikbare snelheid kan draaien. De afweging is insteltijd, geheugenlimieten en de snelheid van de GPU of CPU die je hebt.
Een gehost endpoint ruilt dat in voor lage gebruikskosten. Je verzendt prompts over het netwerk en het model draait op de hardware van een ander. Dit betekent hier een open-weight model, afgestemd op antwoorden zonder inhoudsweigeringen voor wettelijk toegestaan gebruik door volwassenen, aangeboden via een OpenAI-compatibele API. Prompts worden niet gebruikt voor training, maar ze verlaten wel je machine. Een gehoste dienst is dus de verkeerde keuze als je regel is dat data je machine nooit mag verlaten.
Het nuttige voor een LangChain-ontwikkelaar is dat de code nauwelijks verschilt. Lokale servers zoals Ollama en llama.cpp bieden endpoints in OpenAI-stijl, en een gehost endpoint gebruikt hetzelfde protocol. Als je je app schrijft tegen ChatOpenAI met een configureerbare base URL, kun je lokaal ontwikkelen en overschakelen naar een gehost model met een omgevingsvariabele. Dat geeft je een praktische hybride: itereren op een klein lokaal model, en het gehoste model gebruiken wanneer je het gedrag van een groter model wilt zonder de GPU te bezitten.
Verbind ChatOpenAI met het endpoint
Installeer het integratiepakket en maak vervolgens het modelobject aan met de drie instellingen die er toe doen.
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)
Als dit draait, werkt al het andere op dezelfde manier. Haal je sleutel op de API key-pagina; nieuwe gebruikers kunnen daar met één klik $0,50 aan proeftegoed claimen na het aanmelden, zonder creditcard. Geef de base URL expliciet door in code in plaats van te vertrouwen op een omgevingsvariabele, omdat verschillende bibliotheekversies verschillende variabele namen lezen en een stille fallback naar de standaard OpenAI-host je sleutel naar de verkeerde plaats zou sturen.
De modelnaam is de enige plek waar mensen struikelen. De enige ID hier is uncensored. Een naam zoals llama3 of gpt-4o wordt niet herkend.
Een chain met een prompt template
De standaard pipeline van prompt, model en output parser draait ongewijzigd. Dit voorbeeld vat tekst samen in een gekozen toon.
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..."}))
Voor veel invoer, gebruik batch en beperk de paralleliteit. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe, dus houd de instelling op 8 of lager:
results = chain.batch(
[{"tone": "dry", "text": t} for t in documents],
config={"max_concurrency": 6},
)
Een proefsleutel staat slechts 2 gelijktijdige verzoeken en 60 per minuut toe, dus gebruik max_concurrency van 2 tijdens het testen.
Streaming
De API streamt over Server-Sent Events, en LangChain beschikbaar maakt dit via stream. Gebruik het voor chatinterfaces waar een persoon het antwoord ziet vormen.
for chunk in llm.stream("Write a short scene set in a lighthouse."):
print(chunk.content, end="", flush=True)
Een praktisch detail: een gestreamd verzoek houdt zijn concurrency slot vast tot de stream klaar is. Als je UI een stream halverwege verlaat, zorg er dan voor dat de generator wordt gesloten, of je concurrency headroom krimpt. Async code gebruikt astream op dezelfde manier.
Tools en agents
Tool calling wordt ondersteund: de API accepteert tools en tool_choice, streamt tool_calls en ontvangt resultaten terug als role: "tool" berichten. LangChain wikkelt dit 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)
Het resultaat somt de calls op die het model wil, met namen en argumenten. Voer ze uit, voeg de resultaten toe als toolberichten en roep het model opnieuw aan, of laat een agentframework zoals LangGraph die lus draaien. Agents maken veel calls per gebruikersverzoek, dus ze raken de per-minuut limiet sneller dan eenvoudige chains. Tel calls per run voordat je een concurrency level kiest.
Het contextvenster is 100.000 tokens voor prompt plus voltooiing, wat ruim is voor gespreksgeheugen. Knip oude beurten toch: je betaalt voor de hele geschiedenis bij elke call tegen $0,15 per 1M input tokens.
JSON-output
JSON-modus is beschikbaar via response_format. In LangChain kun je het doorgeven met model_kwargs of de gestructureerde output helper in JSON-modus gebruiken, en de velden in je prompt beschrijven.
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)
Met method="json_mode" moet de prompt het model vertellen welke keys te produceren; de Pydantic-class valideert vervolgens het verwerkte resultaat. Houd een retry eromheen voor de zelden voorkomende slechte reply.
Wat niet wordt ondersteund
Twee LangChain-basisfuncties hebben een andere bron nodig. De API heeft geen embeddings endpoint, dus OpenAIEmbeddings die hier wijst, zal falen. Voor retrieval over je documenten, gebruik een lokaal embedding model of een andere embeddingprovider, en gebruik dit endpoint alleen voor de chatstap. Het heeft ook geen invoer of generatie van afbeeldingen, geen audio en geen fine-tuning, dus vision chains en multimodale loaders vallen af.
Foutafhandeling gaat vooral over 429-responsen. De code rate_limited betekent dat je de per-minuut limiet hebt overschreden, concurrency betekent te veel parallelle calls, en een 429 met Retry-After: 5 markeert tijdelijke overbelasting. Stel max_retries in op ChatOpenAI zodat de client wacht en opnieuw probeert. Mislukte en geweigerde verzoeken worden niet in rekening gebracht.
De response headers helpen bij monitoring: X-Balance-USD toont je resterende tegoed en X-Request-Id identificeert een call voor ondersteuning.
Schakelen tussen lokaal en gehost met één variabele
Als je de hybride setup wilt, zet de drie instellingen in omgevingsvariabelen en bouw het model in één functie. Je chains importeren die functie en noemen nooit een leverancier.
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"],
)
De lokale tak gaat uit van een Ollama-server op zijn standaardpoort, die een OpenAI-achtige route beschikbaar maakt onder /v1; raadpleeg de documentatie van je eigen server voor het juiste adres en modelnaam. Gedrag verschilt tussen modellen, dus herhaal je prompts na een switch. Een prompt afgestemd op de gewoonten van het ene model kan zich bij een ander model anders gedragen, en de kwaliteit van tool calling varieert met het model, dus test die paden eerst.
Een verstandige workflow is om prompts te ontwikkelen tegen het gehoste model terwijl je geen GPU vrij hebt, en dan te beslissen welke delen van de app op je eigen machine moeten blijven. Gevoelige documenten kunnen de lokale tak gebruiken, en publieke creatieve functies kunnen het gehoste model gebruiken.
Kosten en vervolgstappen
Prijzen zijn $0,15 per 1M input tokens en $0,50 per 1M output tokens, van prepaid tegoed zonder abonnement. Een chain call met 2.000 input tokens en 500 output tokens kost 2.000 x $0,15 / 1M + 500 x $0,50 / 1M = $0,0003 + $0,00025 = $0,00055. Duizend van dergelijke calls kosten $0,55. Top-ups lopen van $20 tot $500 per crypto (USDT op TRC20, USDC op Base), met een bonus van 5% vanaf $50, 10% vanaf $100 en 15% vanaf $200. Details staan op de prijzenpagina.
Voor een plain-HTTP-weergave van dezelfde API, lees de quickstart. De site heeft ook een kort overzicht van de pay-as-you-go service.
