Documentation IA agentique LangChain : outils et mode JSON
La plupart de la documentation IA agentique LangChain suppose une classe de modèle propre à un fournisseur, mais n'importe quel endpoint compatible OpenAI fonctionne avec ChatOpenAI une fois que vous avez défini une URL de base. Ce guide connecte LangChain à cette API et construit un agent à appel de fonctions étape par étape.
Mis à jour le
Points clés
- Utilisez ChatOpenAI avec base_url défini sur cette API et model défini sur
uncensored. - L'appel de fonctions et le mode JSON sont pris en charge, donc bind_tools et response_format fonctionnent comme documenté.
- Limitez les boucles d'agent, validez les arguments des outils et maintenez max_concurrency à 8 ou moins sur une clé complète.
- Le streaming via SSE renvoie l'utilisation des tokens à la fin, ce qui vous aide à suivre le coût de chaque exécution d'agent.

Ce dont vous avez besoin avant de commencer
Si vous lisez la documentation LangChain sur l'IA agentique et vous demandez ce qui change lorsque le modèle n'est pas celui du fournisseur dans les exemples, la réponse est très peu de choses. Un agent LangChain est une boucle : le modèle lit la conversation, décide s'il doit appeler un outil, votre code exécute l'outil, et le résultat est renvoyé au modèle jusqu'à ce qu'il produise une réponse finale. L'endpoint du modèle doit uniquement prendre en charge les complétions de chat avec appel d'outils, et cette API le fait.
Vous avez besoin de trois choses : une clé API depuis la page des clés, Python 3.10 ou plus récent, et les packages ci-dessous. L'URL de base est https://api.unlimitedaiapi.com/v1 et l'ID du modèle est uncensored. C'est un modèle à poids ouverts exécuté par un fournisseur indépendant, donc il n'y a pas de liste de modèles à choisir ; GET /v1/models le renvoie pour la découverte par le client.
pip install -U langchain langchain-openai
export UNLIMITED_API_KEY="your-key-here"Étape 1 : connecter ChatOpenAI à l'endpoint
La classe ChatOpenAI de LangChain prend une base_url personnalisée. Tout le reste reste identique, y compris invoke, stream, batch et les variantes 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)
Si cela affiche une phrase, l'authentification, le routage et le nom du modèle sont tous corrects. L'authentification utilise l'en-tête standard Authorization: Bearer, que la classe ajoute pour vous. Une erreur courante est d'oublier /v1 dans l'URL de base, ce qui fait généralement échouer le premier appel.
Étape 2 : définir les outils et les lier
Les outils sont de simples fonctions Python avec une docstring. La docstring et les indications de type deviennent le schéma que voit le modèle, alors rédigez-les comme si vous expliquiez la fonction à un nouveau collègue.
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)
La liste imprimée contient un appel avec le nom get_order_status et des arguments tels que {"order_id": "A100"}. En coulisses, LangChain envoie votre fonction en tant qu'entrée dans le tableau tools de la requête de complétions de chat, et l'API prend en charge tools, tool_choice et les tool_calls en streaming. Pour forcer un appel d'outil, passez tool_choice à bind_tools.
Pourquoi la température est faible
Les agents enchaînent plusieurs appels de modèle, donc un seul argument malformé peut dérailler une exécution. Une température de 0 à 0,2 rend la sélection d'outils plus reproductible. Augmentez-la uniquement pour l'étape de réponse finale si vous souhaitez une prose plus variée.
Étape 3 : exécuter la boucle d'agent
Écrire la boucle vous-même prend quinze lignes et montre exactement ce qui se passe à chaque étape, ce qui aide lorsque quelque chose se passe mal. Les résultats des outils sont renvoyés au modèle sous forme d'objets ToolMessage, qui deviennent des messages role: "tool" sur le fil.
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)
Notez le range(5). Un agent sans limite d'étapes peut boucler indéfiniment sur un résultat d'outil déroutant, et chaque passage coûte des tokens d'entrée pour toute la conversation jusqu'à présent. Cinq est un plafond raisonnable pour des tâches simples ; augmentez-le délibérément.
Utilisation de l'assistant d'agent préconstruit
Les versions récentes de LangChain incluent un assistant qui exécute cette boucle pour vous. Le nom et le chemin d'importation ont changé entre les versions, donc vérifiez-les par rapport à la documentation de la version installée. Dans la ligne 1.x actuelle, cela ressemble à ceci :
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)
Utilisez l'assistant lorsque vous voulez le modèle standard, et la boucle écrite à la main lorsque vous avez besoin de règles d'arrêt personnalisées, de logs par étape, ou de résultats d'outils que vous souhaitez filtrer avant que le modèle ne les voie.
Sortie structurée avec le mode JSON
Les agents ont souvent besoin de transmettre des données à d'autres codes, tels qu'un plan, une classification ou une liste de champs extraits. Le mode JSON force la réponse à être un objet JSON valide. Dans LangChain, vous pouvez le passer 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))
Mentionnez le mot JSON dans le prompt et décrivez les clés que vous attendez, comme dans l'exemple. Le mode JSON garantit la syntaxe, pas votre schéma, donc validez toujours l'objet analysé (avec Pydantic, par exemple) et gérez une clé manquante.
Limites, streaming et coût des exécutions d'agents
Les agents effectuent de nombreux appels en peu de temps, donc les limites du compte sont plus importantes que pour un chatbot simple. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 et 60. Si vous répartissez la charge en parallèle avec batch ou exécutez plusieurs agents en même temps, limitez le parallélisme dans la configuration :
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)
Utilisez 2 au lieu de 8 sur la clé d'essai. Pour les agents interactifs, llm.stream(...) renvoie des tokens via SSE au fur et à mesure de leur génération, et les chiffres d'utilisation arrivent à la fin du flux.
Le coût est facile à estimer. Une exécution en 5 étapes qui moyenne 4 000 tokens d'entrée et 300 tokens de sortie par étape utilise 20 000 tokens d'entrée et 1 500 tokens de sortie au total, ce qui représente 0,003 $ + 0,00075 $ = 0,00375 $ par exécution à 0,15 $ et 0,50 $ par 1M tokens. La page tarifs a les taux, et la documentation liste les paramètres de requête et les en-têtes, y compris X-Request-Id pour tracer un seul appel défaillant.
Conception des outils utilisables par le modèle
La plupart des échecs d'agents remontent aux outils, pas à la boucle. Quelques règles aident avec n'importe quel modèle :
- Gardez chaque outil étroit. Un outil appelé
get_order_statusfonctionne mieux qu'un appelédatabase_queryqui prend du texte libre. - Utilisez des types d'arguments simples : chaînes, entiers et énumérations courtes. Les objets profondément imbriqués donnent au modèle plus de façons de se tromper sur un champ.
- Renvoyez des résultats courts et simples. Un outil qui déverse 50 000 caractères dans la conversation remplit la fenêtre de contexte et augmente le coût de chaque étape ultérieure.
- Renvoyez les erreurs sous forme de texte, comme « order_id doit ressembler à A100 », au lieu de lever des exceptions qui mettent fin à l'exécution.
Testez l'agent sur une poignée de prompts réels avec le crédit d'essai de 0,50 $ avant de passer à l'échelle. Les nouveaux utilisateurs l'obtiennent en un clic sur la page des clés, et il est valable 7 jours.
Pièges à vérifier en premier
- L'appel d'outil n'apparaît jamais. Rendez la docstring spécifique, abaissez la température, ou forcez l'appel avec
tool_choice. - Arguments invalides. Validez à l'intérieur de l'outil et renvoyez une chaîne d'erreur claire, afin que le modèle puisse se corriger à l'étape suivante.
- Croissance du contexte. La fenêtre est de 100 000 tokens incluant la réponse. Nettoyez les anciennes sorties d'outil avant qu'elles ne remplissent la fenêtre.
Plus de guides
Questions et réponses
Quelle classe LangChain fonctionne avec cette API ?
ChatOpenAI de langchain-openai. Définissez base_url sur https://api.unlimitedaiapi.com/v1, model à uncensored et passez votre clé en tant que api_key.
L'API prend-elle en charge l'appel de fonctions pour les agents ?
Oui. Elle accepte les paramètres tools et tool_choice, renvoie tool_calls (même en streaming) et accepte les résultats en tant que messages avec role tool.
LangChain peut-il analyser une sortie structurée via cette API ?
Oui, via le mode JSON : définissez response_format sur un type json_object. Il garantit une syntaxe JSON valide, donc validez vous-même les champs.
Combien d'agents puis-je exécuter en parallèle ?
Une clé complète permet 8 requêtes simultanées et 300 par minute. La clé d'essai permet 2 requêtes simultanées et 60 par minute.
Votre clé n'est qu'à un formulaire d'ici
Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.