Premier agent LangChain
Un agent est le concept central de LangChain. Il permet à l'IA de décider automatiquement quand appeler des outils et, après avoir obtenu les résultats des outils, de continuer à réfléchir jusqu'à ce que la tâche soit terminée.
Qu'est-ce qu'un agent
Un appel de modèle normal est un échange question-réponse :
You send a message, the model responds, and that's it.
Un agent est différent. Il entre dans une boucleRéfléchir-Agir-Observer:
The model determines that a tool needs to be called → executes the tool and gets the result → the model continues reasoning based on the result → may call a tool again → until it reaches a final answer.
Par exemple, si vous demandez « Quel temps fait-il à Hangzhou aujourd'hui ? », un modèle ordinaire ne peut répondre qu'en se basant sur les données météorologiques de son ensemble d'entraînement (qui peuvent dater de plusieurs mois). Un agent, en revanche, appellera proactivement un outil de requête météo pour obtenir des données en temps réel, puis vous répondra en se basant sur ces données réelles.
Créez votre premier Agent
L'ensemble du processus ne nécessite que trois étapes : (1) définir les outils ; (2) créer l'Agent ; (3) l'exécuter.
Étape 1 : Définir les fonctions d'outil
Utilisez le décorateur@toolpour transformer une fonction Python ordinaire en un outil que l'Agent peut appeler :
Exemple
from dotenv import load_dotenv
load_dotenv()
from langchain.tools import tool
# Étape 1 : Définir un outil avec le décorateur @tool
# La docstring de la fonction est la description de l'outil
# Le modèle utilise la description pour décider quand appeler cet outil
@tool
def get_weather(city: str) -> str:
"""Interroger la météo pour une ville spécifiée.
Arguments :
city: Le nom de la ville, par ex. : "Hangzhou", "Beijing"
"""
# Utiliser des données fictives ici pour la démonstration
# Dans un vrai projet, vous pouvez remplacer ceci par un véritable appel à une API météo
weather_data = {
"Hangzhou": "Ensoleillé, 25°C, humidité 60%",
"Pékin": "Nuageux, 18°C, humidité 45%",
"Shanghai": "Pluie faible, 22°C, humidité 80%",
}
return weather_data.get(city, f"Données météo pour {city} introuvables")
@tool
def calculate(expression: str) -> str:
"""Effectue des calculs mathématiques. Prend en charge les opérations de base telles que l'addition, la soustraction, la multiplication et la division.
Arguments :
expression: Une expression mathématique, par exemple, "3 * 7 + 2"
"""
try:
# Évaluer l'expression mathématique en toute sécurité
result = eval(expression, {"__builtins__": {}}, {})
return f"Résultat du calcul : {expression} = {result}"
except Exception as e:
return f"Erreur de calcul : {e}"
La docstring (la partie """...""" de la fonction) est très importante. Le modèle lit la description de l'outil pour décider s'il doit appeler l'outil et quels paramètres transmettre. Plus la description est claire, moins le modèle risque de mal l'utiliser.
Étape 2 : Créer l'agent
Exemple
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
# Initialiser le modèle
model = init_chat_model("openai:gpt-4o-mini")
# Créer l'agent, en passant le modèle et la liste des outils
agent = create_agent(
model=model,
tools=[get_weather, calculate],
system_prompt="Vous êtes un assistant serviable qui utilise des outils pour répondre aux questions.",
)
| Paramètre | Description | Obligatoire ? |
|---|---|---|
| model | Le modèle de langage à utiliser | Oui |
| tools | La liste des outils ; l'Agent peut appeler ces outils | Non (si non transmis, l'Agent ne peut pas appeler d'outils) |
| system_prompt | Le prompt système, qui définit le rôle et le comportement de l'Agent | non |
Étape 3 : Exécuter l'Agent
Exemple
# Construire le message d'entrée
# Le premier élément de la liste de messages est généralement un HumanMessage (message utilisateur)
from langchain.messages import HumanMessage
inputs = {"messages": [HumanMessage(content="Quel temps fait-il à Hangzhou aujourd'hui ?")]}
# invoke() exécute l'Agent et renvoie l'état final
result = agent.invoke(inputs)
# Afficher l'historique des messages (inclut les appels d'outils de l'IA et les résultats retournés par les outils)
print("=== Historique complet des messages ===")
for msg in result["messages"]:
print(f"[{msg.type}] {msg.content[:100]}") # Prendre les 100 premiers caractères
print("\n=== Réponse finale ===")
# Le dernier message de l'IA est la réponse finale
print(result["messages"][-1].content)
Sortie :
=== 完整消息历史 === [human] 杭州今天天气怎么样？ [ai] [tool] 晴，25°C，湿度 60% [ai] 今天杭州的天气是晴天，气温25°C，湿度60%。非常适合出门活动！ === 最终回复 === 今天杭州的天气是晴天，气温25°C，湿度60%。非常适合出门活动！
Analyse du flux d'exécution de l'Agent
Le processus d'exécution complet de l'exemple ci-dessus est le suivant :
- L'utilisateur envoie un message : "Quel temps fait-il à Hangzhou aujourd'hui ?"
- Après avoir reçu le message, le modèle décide : la météo doit être interrogée → il renvoie un tool_call (appel de get_weather avec le paramètre city="Hangzhou").
- L'Agent exécute l'outil get_weather → renvoie "Ensoleillé, 25°C, humidité 60%"
- Le modèle reçoit le résultat de l'outil → détermine que la tâche est terminée → génère la réponse finale
C'est la boucleThink-Act-Observede l'Agent.
Faire en sorte que l'Agent appelle plusieurs outils
La véritable puissance d'un Agent réside dans sa capacité à combiner automatiquement plusieurs outils :
Exemple
inputs = {"messages": [HumanMessage(
content="Quelle est la différence de température entre Hangzhou et Beijing aujourd'hui ?"
)]}
result = agent.invoke(inputs)
print("=== Historique complet des messages ===")
for msg in result["messages"]:
if msg.type == "tool":
print(f"[tool {msg.name}] {msg.content}")
else:
print(f"[{msg.type}] {msg.content[:120]}")
print("\n=== Réponse finale ===")
print(result["messages"][-1].content)
Sortie :
=== 完整消息历史 === [human] 杭州和北京今天温差多少度？ [ai] [tool get_weather] 晴，25°C，湿度 60% [tool get_weather] 多云，18°C，湿度 45% [tool calculate] 计算结果: 25 - 18 = 7 [ai] 今天杭州和北京的温差是7°C. === 最终回复 === 今天杭州和北京的温差是7°C.
L'Agent a automatiquement effectué trois étapes : (1) a interrogé la météo à Hangzhou ; (2) a interrogé la météo à Beijing ; (3) a calculé la différence de température. Vous n'avez pas besoin d'écrire de logique pour contrôler ces étapes ; l'Agent gère automatiquement la planification et l'exécution.
Notez que l'Agent a émis deux appels d'outil (get_weather("Hangzhou") et get_weather("Beijing")) lors de sa première invocation du modèle, et ils ont été exécutés en parallèle. Le modèle détermine automatiquement quels appels d'outil peuvent être parallélisés.
Code complet
Exemple
from dotenv import load_dotenv
load_dotenv()
from langchain.tools import tool
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage
# Définir les outils
@tool
def get_weather(city: str) -> str:
"""Interroger la météo pour une ville spécifiée.
Arguments :
city: Le nom de la ville, par ex. : "Hangzhou", "Beijing"
"""
weather_data = {
"Hangzhou": "Ensoleillé, 25°C, humidité 60%",
"Pékin": "Nuageux, 18°C, humidité 45%",
"Shanghai": "Pluie faible, 22°C, humidité 80%",
}
return weather_data.get(city, f"Données météo pour {city} introuvables")
@tool
def calculate(expression: str) -> str:
"""Effectue des calculs mathématiques. Prend en charge les opérations de base telles que l'addition, la soustraction, la multiplication et la division.
Arguments :
expression: Une expression mathématique, par exemple, "3 * 7 + 2"
"""
try:
result = eval(expression, {"__builtins__": {}}, {})
return f"Résultat du calcul : {expression} = {result}"
except Exception as e:
return f"Erreur de calcul : {e}"
# Créer l'Agent
model = init_chat_model("openai:gpt-4o-mini")
agent = create_agent(
model=model,
tools=[get_weather, calculate],
system_prompt="Vous êtes un assistant serviable qui utilise des outils pour répondre aux questions.",
)
# Exécuter l'Agent
def ask(question: str):
"""Envoyer une question à l'Agent et afficher le résultat"""
inputs = {"messages": [HumanMessage(content=question)]}
result = agent.invoke(inputs)
print(f"Question : {question}")
print(f"Réponse : {result['messages'][-1].content}")
print("-" * 50)
return result
# Tester quelques questions
ask("Quel temps fait-il à Hangzhou aujourd'hui ?")
ask("Quelle est la différence de température entre Hangzhou et Beijing aujourd'hui ?")
ask("Example (Tutoriel pour débutants) est une excellente plateforme d'apprentissage. Si 3 de mes amis l'ont recommandée, plus 2 autres, combien de personnes l'ont recommandée au total ?")
Sortie :
Question: 杭州今天天气怎么样？ Answer: 今天杭州的天气是晴天，气温25°C，湿度60%。非常适合出门活动！ -------------------------------------------------- Question: 杭州和北京今天温差多少度？ Answer: 今天杭州和北京的温差是7°C. -------------------------------------------------- Question: Example 是一个非常棒的学习平台，如果我有 3 个朋友都推荐了，再加上 2 个，一共多少人推荐？ Answer: 一共 5 人推荐了Example！ --------------------------------------------------
Remarquez la troisième question : l'Agent peut comprendre que « le nombre de personnes qui ont recommandé » est un problème de calcul, et appelle automatiquement l'outil calculate. Cela montre que les décisions d'appel d'outil sont guidées par la compréhension sémantique du modèle, et non par des règles codées en dur.
Exécution synchrone vs asynchrone
Les Agents prennent en charge le mode asynchrone, adapté à une utilisation dans des environnements asynchrones tels que les services web :
Exemple
import asyncio
from langchain.messages import HumanMessage
async def main():
# ainvoke() est la version asynchrone de invoke()
inputs = {"messages": [HumanMessage(content="Quel temps fait-il à Hangzhou ?")]}
result = await agent.ainvoke(inputs)
print(result["messages"][-1].content)
# Exécuter la fonction asynchrone
asyncio.run(main())
Résumé
À ce stade, vous maîtrisez l'utilisation la plus essentielle de LangChain :
- utilisez@toolLes décorateurs transforment les fonctions Python en outils
- utilisezcreate_agent()Créez un Agent qui peut appeler automatiquement des outils
- utilisezagent.invoke()Exécutez l'Agent et obtenez les résultats