LangChain Custom LLM API: wijs naar elke Base URL
Om een langchain custom llm api te gebruiken hoef je geen custom class te schrijven: de OpenAI-compatible chat wrapper accepteert een base URL, een sleutel en een modelnaam. Hier is de exacte configuratie, plus streaming, tools, JSON output en limietafhandeling.
Belangrijkste punten
- ChatOpenAI neemt base_url, api_key en model, dus subclassing is niet nodig.
- Gebruik model uncensored en de base URL https://api.llmapistatus.com/v1.
- Tool calling, streaming en JSON-modus gaan allemaal via de endpoint.
- Beperk parallelle chains tot 8 om onder de concurrency limit te blijven; embeddings worden niet aangeboden.

Het korte antwoord: ChatOpenAI met een andere base URL
LangChain communiceert met OpenAI-achtige servers via het langchain-openai pakket. Met de ChatOpenAI-klasse kun je overschrijven waar verzoeken naartoe gaan, wat precies is wat een custom endpoint nodig heeft. Installeer het pakket en geef drie waarden door: de base URL https://api.llmapistatus.com/v1, je sleutel en de model ID uncensored.
Installeer met 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)
Als dat een antwoord print, is de bedrading correct. Je krijgt een sleutel van de API-sleutel-pagina; de quickstart toont dezelfde schakelaar voor gewone SDK-gebruikers. De endpoint serveert POST /v1/chat/completions en GET /v1/models, en die twee methoden zijn alles wat de OpenAI-wrapper nodig heeft voor chat.
Een woord over de term "custom LLM". LangChain documenteert ook een manier om je eigen chat model te schrijven door een base class te subclassen, wat zinvol is voor API's die niet het OpenAI-formaat spreken. Deze endpoint spreekt het wel, dus subclassen voegt alleen code toe om te onderhouden. Pak het alleen als je gedrag nodig hebt dat de wrapper niet kan uitdrukken.
Een chain bouwen met prompts en output parsing
Zodra het modelobject klaar is, werkt al het andere in LangChain zoals met elk chat model. Hier is een kleine chain geschreven in de expression-language stijl: een prompt template, het model en een 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.",
}))
Niets in deze chain weet of geeft er niets om dat het model achter een ander domein zit. Dat is het voordeel van de compatible API: prompts, memory classes, retrievers en agents geschreven tegen de standaard chat interface blijven werken. Wat je aan je kant moet controleren is de prompt zelf. Een model dat is afgestemd op het beantwoorden zonder content refusals volgt instructies letterlijk, dus vage system prompts leiden tot vaag gedrag. Geef de rol, het formaat en de lengte aan.
Een limiet is het waard om te weten voordat je een retrieval pipeline ontwerpt. Deze service is alleen tekst. Er zijn geen embeddings, dus OpenAIEmbeddings die op deze base URL wijzen, zullen falen. Gebruik een lokaal embedding model of een andere provider voor de vector store, en gebruik deze endpoint alleen voor generatie.
Streaming tokens terwijl ze binnenkomen
De endpoint ondersteunt server-sent events als je stream: true verzendt, en LangChain zet dat om in een iterator. Je stelt de flag niet zelf in; het aanroepen van .stream() doet dit.
# 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()
Voor async servers gebruik je astream. Dezelfde aanroep bestaat in de JavaScript bibliotheek:
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);
}
Onthoud dat een gestreamd verzoek zijn concurrency slot vasthoudt tot het laatste event aankomt. Als een gebruiker het browsertabblad sluit en je server blijft de stream lezen, blijft dat slot bezet. Annuleer het upstream verzoek als de client disconnecteert. Usage nummers komen aan het einde van de stream, waar je de laatste token counts voor billing logs leest.
Function calling en agents
Tool calling is beschikbaar: de endpoint accepteert tools en tool_choice, streams tool_calls terug, en neemt je resultaten als berichten met role: "tool". In LangChain koppel je tools met bind_tools en laat het framework de berichten bouwen.
# 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)
Het uitvoeren van de aanroep en het retourneren van het resultaat is de tweede helft van de lus:
# 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 modellen variëren in hoe goed ze tools kiezen en argumenten invullen. Houd tool beschrijvingen kort en concreet, gebruik weinig tools per aanroep, en valideer argumenten in je functie in plaats van ze te vertrouwen. Als een agent in een lus raakt, verlaag dan de temperature en stel een maximum aantal stappen in je agent executor in.
Gestructureerde en JSON-output
JSON-modus wordt ondersteund via response_format: {"type": "json_object"}. In LangChain is de makkelijkste route with_structured_output met de JSON-mode methode, die het resultaat ook valideert tegen een schema.
# 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 garandeert dat de output een JSON object is, niet dat het de velden heeft die je wilde. Twee gewoontes helpen. Noem eerst de keys in de prompt, zoals hierboven; de instructie om JSON te produceren moet expliciet zijn. Wrap de aanroep daarna in een retry die opnieuw parseert bij falen. De pydantic check vangt missende velden en verkeerde types op, en een enkele retry met het error bericht erbij lost meestal het probleem op.
Je kunt ook response_format direct instellen wanneer je het model bouwt met model_kwargs={"response_format": {"type": "json_object"}}, wat handig is voor gewone chains die eindigen in een JSON parser.
Rate limits, retries en parallelle chains
Batch taken en agents maken veel aanroepen tegelijk, en hier verschilt een custom endpoint van een lokaal model. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefsleutel staat 2 gelijktijdige en 60 per minuut toe. Na een limiet antwoordt de API met HTTP 429 en de error code rate_limited of concurrency; bij tijdelijke overbelasting antwoordt het 429 met Retry-After: 5.
Twee LangChain instellingen handelen het meeste af. Het model neemt max_retries, wat tijdelijke fouten opnieuw probeert met backoff, en runnables accepteren een max_concurrency waarde in hun config voor batch werk:
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})
Het instellen van de cap op 6 op een volledige sleutel laat ruimte voor twee andere verzoeken, zoals een user-facing call van dezelfde app. Gebruik op een proefsleutel 1 of 2. Vertrouw niet alleen op retries voor een concurrency probleem: als de cap boven de limiet ligt, recreëren retries gewoon dezelfde botsing. Het lezen van X-RateLimit-Limit-Requests en X-RateLimit-Limit-Concurrency uit de response headers vertelt je wat je sleutel mag.
Lange inputs zijn prima tot het 100.000-token venster, gedeeld tussen prompt en completion, en de request body is beperkt tot 8 MB. LangChain text splitters ingesteld op een paar duizend tokens per chunk houden je ver van beide.
Foutopsporing bij een custom endpoint
De meeste problemen met een custom base URL vallen onder een korte lijst, en elk heeft een snelle test.
- Authentication fouten. LangChain leest ook de omgevingsvariabele
OPENAI_API_KEY. Als jeapi_keyexpliciet doorgeeft, wint die waarde, maar een verouderde variabele kan nog steeds een tweede modelobject verwarren dat je vergeten was te configureren. Geef de sleutel elke keer door en geef de variabele een andere naam, zoalsLLM_API_KEY. - Not found fouten. De base URL moet eindigen op
/v1. LangChain voegt zelf/chat/completionstoe, dus het toevoegen aan de base URL resulteert in een verdubbeld pad. - Onbekend model. Vraag
GET /v1/modelsmet dezelfde sleutel en kopieer de ID die het afdrukt. Het zouuncensoredmoeten zijn. - Stille hangers in lange ketens. Stel
timeoutin op het model en log de responsheaderX-Request-Id. Als je contact opneemt met support, kan support met die ID het exacte verzoek vinden. - Verrassende output. Print de laatste prompt voordat deze wordt verzonden. De meeste vreemde antwoorden in LangChain komen van een sjabloon dat een variabele vulde met iets onverwachts, niet van het model.
Twijfel je? Reproduceer dan het mislukte verzoek met plain curl tegen dezelfde URL. Als curl werkt en LangChain niet, ligt de fout bij jouw keten; als beide falen, controleer dan de sleutel en het saldo.
Kosten controleren tijdens het bouwen
Chains verbergen token counts, dus meet vroeg. Elk antwoord bevat usage, en de response headers bevatten X-Balance-USD. De prijs is $0,15 per 1M input tokens en $0,50 per 1M output tokens, gefactureerd van prepaid credit.
Een werkvoorbeeld: een retrieval chain die 6.000 tokens context en vraag verstuurt en 400 tokens terugkrijgt, kost 6.000 x $0,15 / 1M = $0,0009 voor input plus 400 x $0,50 / 1M = $0,0002 voor output, dus $0,0011 per call. 5.000 van zulke calls in een testrun kosten $5,50. Dat is handig om te weten voordat je een agent loop de hele nacht laat draaien.
Mislukte of geweigerde verzoeken worden niet in rekening gebracht. De prijzenpagina geeft top-up bedragen van $20 tot $500 met bonussen, en nieuwe accounts kunnen met één klik $0,50 trial tegoed claimen, genoeg voor een paar honderd kleine test calls terwijl je de integratie opzet.
Meer handleidingen
Vragen en antwoorden
Moet ik de chat model base class van LangChain subklassen?
Nee. De endpoint is OpenAI-compatible, dus ChatOpenAI met een custom base_url, api_key en model werkt. Subklasseren is alleen nodig voor APIs die een ander formaat gebruiken.
Kan ik OpenAIEmbeddings met deze endpoint gebruiken?
Nee. De service is alleen tekst en heeft geen embeddings. Gebruik een lokaal embedding model of een andere provider voor vectors, en gebruik deze endpoint voor generatie.
Welke model name geef ik mee?
Geef uncensored mee als model. GET /v1/models retourneert dezelfde ID.
Waarom krijg ik 429 fouten in een batch job?
Je hebt de limiet voor verzoeken per minuut of gelijktijdige verzoeken overschreden. Verlaag max_concurrency onder 8 op een volledige key, of 2 op een trial key, en houd retries ingeschakeld.
Werkt LangChain's streaming hier?
Ja. Het aanroepen van stream of astream gebruikt server-sent events, en usage wordt aan het einde van de stream verstuurd.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.