LangChain Agentic AI-documentatie: tools en JSON-modus
De meeste documentatie over LangChain agentic AI gaat uit van een modelclass van de leverancier zelf, maar elk OpenAI-compatibel endpoint werkt met ChatOpenAI zodra je een base URL instelt. Deze gids koppelt LangChain aan deze API en bouwt stap voor stap een agent met function calling.
Bijgewerkt
Belangrijkste punten
- Gebruik ChatOpenAI met base_url ingesteld op deze API en model ingesteld op
uncensored. - Function calling en JSON-modus worden ondersteund, dus bind_tools en response_format werken zoals gedocumenteerd.
- Beperk agentlussen, valideer toolargumenten en houd max_concurrency op of onder 8 voor een volledige sleutel.
- Streaming via SSE retourneert tokengebruik aan het einde, wat je helpt de kosten van elke agentrun bij te houden.

Wat je nodig hebt voordat je begint
Als je documentatie over LangChain agentic AI leest en je afvraagt wat er verandert als het model niet van de leverancier in de voorbeelden is, is het antwoord weinig. Een agent in LangChain is een lus: het model leest het gesprek, beslist of het een tool moet aanroepen, jouw code voert de tool uit en het resultaat gaat terug naar het model totdat het een definitief antwoord produceert. Het modelendpoint hoeft alleen chatcompleties met function calling te ondersteunen, en dat doet deze API.
Je hebt drie dingen nodig: een API-sleutel van de sleutelpagina, Python 3.10 of nieuwer, en de onderstaande pakketten. De base URL is https://api.unlimitedaiapi.com/v1 en de model-ID is uncensored. Het is één open-weight model dat door een onafhankelijke provider wordt uitgevoerd, dus er is geen modellenlijst om uit te kiezen; GET /v1/models retourneert het voor clientontdekking.
pip install -U langchain langchain-openai
export UNLIMITED_API_KEY="your-key-here"Stap 1: ChatOpenAI verbinden met het endpoint
De ChatOpenAI-klasse van LangChain accepteert een aangepaste base_url. Al het andere blijft hetzelfde, inclusief de varianten invoke, stream, batch en async.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0.2,
)
print(llm.invoke("Reply with one short sentence.").content)
Als dit een zin afdrukt, zijn authenticatie, routing en de modelnaam allemaal correct. Authenticatie is de standaard Authorization: Bearer header, die de klasse voor je toevoegt. Een veelgemaakte fout is het weglaten van /v1 in de base URL, waardoor de eerste call meestal faalt.
Stap 2: definieer tools en koppel ze
Tools zijn gewone Python-functies met een docstring. De docstring en de type hints worden het schema dat het model ziet, dus schrijf ze alsof je de functie aan een nieuwe collega uitlegt.
import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
llm_with_tools = llm.bind_tools([get_order_status])
ai = llm_with_tools.invoke("Where is order A100?")
print(ai.tool_calls)
De afgedrukte lijst bevat een aanroep met de naam get_order_status en argumenten zoals {"order_id": "A100"}. Onder de motorkap stuurt LangChain jouw functie als een item in de tools-array van het chat completions-verzoek, en de API ondersteunt tools, tool_choice en gestreamde tool_calls. Om een toolaanroep af te dwingen, geef je tool_choice door aan bind_tools.
Waarom de temperatuur laag is
Agents koppelen meerdere modelaanroepen aan elkaar, dus één foutief argument kan een run laten ontsporen. Een temperatuur van 0 tot 0,2 maakt de toolkeuze beter herhaalbaar. Verhoog die alleen voor de laatste antwoordstap als je gevarieerdere tekst wilt.
Stap 3: de agentlus uitvoeren
De loop zelf schrijven kost vijftien regels en laat precies zien wat er op elke stap gebeurt, wat helpt als er iets misgaat. Toolresultaten gaan terug naar het model als ToolMessage-objecten, die over de lijn role: "tool"-berichten worden.
import os
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
tools = {"get_order_status": get_order_status}
llm_with_tools = llm.bind_tools(list(tools.values()))
messages = [HumanMessage("Where is order A100, and what about A101?")]
for _ in range(5): # hard cap on loop length
ai = llm_with_tools.invoke(messages)
messages.append(ai)
if not ai.tool_calls:
break
for call in ai.tool_calls:
result = tools[call["name"]].invoke(call["args"])
messages.append(ToolMessage(content=str(result), tool_call_id=call["id"]))
print(ai.content)
Let op de range(5). Een agent zonder stappenlimiet kan oneindig blijven doorlopen op een verwarrend toolresultaat, en elke ronde kost invoertokens voor het hele gesprek tot dan toe. Vijf is een redelijk maximum voor eenvoudige taken; verhoog het bewust.
De ingebouwde agenthelper gebruiken
Recente LangChain-versies leveren een helper die deze lus voor je uitvoert. De naam en het importpad zijn tussen releases verplaatst, dus controleer ze in de docs van de geïnstalleerde versie. In de huidige 1.x-lijn ziet het er zo uit:
import os
from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def get_order_status(order_id: str) -> str:
'''Look up the status of an order by its ID, for example A100.'''
return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
agent = create_agent(llm, tools=[get_order_status], system_prompt="You are a concise support assistant.")
result = agent.invoke({"messages": [{"role": "user", "content": "Where is order A100?"}]})
print(result["messages"][-1].content)
Gebruik de helper als je het standaardpatroon wilt, en de handgeschreven lus als je aangepaste stopregels nodig hebt, logging per stap, of toolresultaten die je wilt filteren voordat het model ze ziet.
Gestructureerde uitvoer met JSON-modus
Agents moeten vaak data doorgeven aan andere code, zoals een plan, een classificatie of een lijst van geëxtraheerde velden. JSON-modus dwingt het antwoord tot een geldig JSON-object. In LangChain kun je het doorgeven via bind:
import json
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
temperature=0,
)
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke(
"Extract the city and country from: 'I moved to Lyon, France last spring.' "
"Answer as JSON with the keys city and country."
)
print(json.loads(msg.content))
Vermeld het woord JSON in de prompt en beschrijf de verwachte sleutels, zoals in het voorbeeld. JSON-modus garandeert syntaxis, niet jouw schema, dus valideer het geparseerde object nog steeds (bijvoorbeeld met Pydantic) en handel een ontbrekende sleutel af.
Limieten, streaming en kosten voor agentruns
Agents doen in korte tijd veel aanroepen, dus de limieten van het account zijn belangrijker dan bij een eenvoudige chatbot. Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefsleutel staat 2 en 60 toe. Als je met batch veel aanroepen tegelijk uitzet of meerdere agents tegelijk draait, beperk dan de parallelliteit in de configuratie:
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.unlimitedaiapi.com/v1",
api_key=os.environ["UNLIMITED_API_KEY"],
)
prompts = ["Name one prime number.", "Name one even number.", "Name one square number."]
answers = llm.batch(prompts, config={"max_concurrency": 8})
for a in answers:
print(a.content)
Gebruik 2 in plaats van 8 op de proefsleutel. Voor interactieve agents geeft llm.stream(...) tokens via SSE terug zodra ze worden gegenereerd, en de gebruiksgegevens komen aan het einde van de stream.
Kosten zijn makkelijk te schatten. Een run van 5 stappen met gemiddeld 4.000 invoer- en 300 uitvoertokens per stap gebruikt in totaal 20.000 invoer- en 1.500 uitvoertokens, wat $0,003 + $0,00075 = $0,00375 per run is bij $0,15 en $0,50 per 1M tokens. De prijspagina vermeldt de tarieven, en de docs vermelden de requestparameters en headers, inclusief X-Request-Id voor het traceren van een enkele falende call.
Tools ontwerpen die het model kan gebruiken
De meeste agentfouten komen terug op de tools, niet op de lus. Een paar regels helpen bij elk model:
- Houd elke tool smal. Een tool genaamd
get_order_statuswerkt beter dan er eentje genaamddatabase_querydie vrije tekst accepteert. - Gebruik eenvoudige argumenttypen: strings, integers en korte enums. Diep geneste objecten geven het model meer manieren om een veld foutief te krijgen.
- Geef korte, eenvoudige resultaten terug. Een tool die 50.000 tekens in het gesprek dumpt, vult het contextvenster en verhoogt de kosten van elke latere stap.
- Geef fouten terug als tekst, zoals "order_id moet eruitzien als A100", in plaats van excepties te gooien die de run beëindigen.
Test de agent op een handvol echte prompts met het proeftegoed van $0,50 voordat je opschaalt. Nieuwe gebruikers krijgen het met één klik op de sleutelpagina, en het is 7 dagen geldig.
Valkuilen om eerst te controleren
- Tool call verschijnt nooit. Maak de docstring specifieker, verlaag de temperatuur, of forceer de call met
tool_choice. - Ongeldige argumenten. Valideer binnen de tool en geef een duidelijke foutmelding terug, zodat het model zichzelf in de volgende stap kan corrigeren.
- Groeiende context. Het venster is 100.000 tokens inclusief het antwoord. Knip oude tooloutput weg voordat het venster vol is.
Meer handleidingen
Vragen en antwoorden
Welke LangChain-class werkt met deze API?
ChatOpenAI van langchain-openai. Stel base_url in op https://api.unlimitedaiapi.com/v1, model op uncensored en geef je sleutel door als api_key.
Ondersteunt de API function calling voor agents?
Ja. Hij accepteert de parameters tools en tool_choice, retourneert tool_calls (ook tijdens streaming) en neemt resultaten terug aan als berichten met role tool.
Kan LangChain gestructureerde output parseren via deze API?
Ja, via JSON-modus: stel response_format in op een json_object-type. Het garandeert geldige JSON-syntaxis, dus valideer de velden zelf.
Hoeveel agents kan ik parallel uitvoeren?
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe. De proefsleutel staat 2 gelijktijdige en 60 per minuut toe.
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.