Stratégies de sortie LangChain
LangChain propose trois stratégies de sortie structurée. Comprendre leurs différences et leur fonctionnement peut vous aider à faire le meilleur choix dans différents scénarios.
Aperçu des trois stratégies
| Stratégie | Principe | Prise en charge des modèles | Vitesse de réponse |
|---|---|---|---|
| ToolStrategy | Déguise le schéma en outil ; le modèle « appelle » cet outil pour produire des données structurées. | Tous les modèles qui prennent en charge l'appel de fonctions | Plus lente (un appel d'outil supplémentaire) |
| ProviderStrategy | Utilise la capacité native de sortie structurée du modèle (par exemple, response_format d'OpenAI) | Certains modèles (GPT-4o+, Claude 3+, etc.) | Plus rapide (sortie directe) |
| AutoStrategy | Détecte automatiquement les capacités du modèle et sélectionne la meilleure stratégie | Adaptation automatique | Sélectionne automatiquement l'optimal |
ToolStrategy — Mode d'appel d'outils
ToolStrategy est l'approche la plus compatible. Il convertit votre Schema en un « faux outil », et le modèle produit des données structurées en appelant cet outil.
Exemple
from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage
class WeatherReport(BaseModel):
"""Rapport météo"""
city: str = Field(description="Nom de la ville")
temperature: float = Field(description="Température (Celsius)")
condition: str = Field(description="Condition météo")
humidity: int = Field(description="Pourcentage d'humidité")
model = init_chat_model("deepseek:deepseek-v4-flash", temperature=0)
# Spécifier explicitement l'utilisation de ToolStrategy
agent = create_agent(
model=model,
response_format=ToolStrategy(schema=WeatherReport),
system_prompt="Vous êtes un assistant météo. Générez un rapport météo structuré en fonction de la description de l'utilisateur.",
)
result = agent.invoke({
"messages": [HumanMessage(content="Hangzhou est ensoleillé aujourd'hui, 25 degrés, humidité 60%")]
})
report = result["structured_response"]
print(f"Ville : {report.city}")
print(f"Température : {report.temperature}°C")
print(f"Condition : {report.condition}")
print(f"Humidité : {report.humidity}%")
# Voir le processus d'exécution — vous pouvez voir un message d'appel d'outil supplémentaire
print(f"\n"Total des messages : {len(result['messages'])}")
for msg in result["messages"]:
print(f" [{msg.type}]", end="")
if hasattr(msg, 'tool_calls') and msg.tool_calls:
print(f" Appels : {[tc['name'] for tc in msg.tool_calls]}")
elif msg.type == "tool":
print(f" {msg.content[:60]}")
else:
print(f" {str(msg.content)[:60]}")
Sortie :
City: 杭州 Temperature: 25.0°C Condition: 晴天 Humidity: 60% Total messages: 4 [human] 杭州今天晴天，温度25度，湿度60% [ai] 调用: ['WeatherReport'] [tool] Returning structured response: ... [ai]
Vous pouvez voir que ToolStrategy ajoute une étape supplémentaire d'appel d'outil (appelant un "faux outil" nommé WeatherReport) avant de produire la sortie structurée.
handle_errors — Réessai en cas d'erreur
ToolStrategy prend en charge la nouvelle tentative automatique lorsque la sortie structurée échoue :
Exemple
# handle_errors=True : lorsque le format de sortie est incorrect, renvoyez le message d'erreur au modèle pour réessayer
strategy_with_retry = ToolStrategy(
schema=WeatherReport,
handle_errors=True, # La valeur par défaut est False
)
# handle_errors peut aussi être un modèle de message d'erreur personnalisé
strategy_custom_error = ToolStrategy(
schema=WeatherReport,
handle_errors="Le format est incorrect. Veuillez le corriger en fonction de {error} et le renvoyer.",
)
ProviderStrategy — Sortie structurée native
ProviderStrategy utilise les capacités natives du fournisseur de modèle (comme le paramètre response_format d'OpenAI). Tous les modèles ne le prennent pas en charge.
Exemple
from langchain.agents import create_agent
from langchain.agents.structured_output import ProviderStrategy
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage
class CourseInfo(BaseModel):
"""Informations sur le cours"""
name: str = Field(description="Nom du cours")
level: str = Field(description="Difficulté : Débutant/Intermédiaire/Avancé")
price: str = Field(description="Informations sur le prix")
model = init_chat_model("deepseek:deepseek-v4-flash", temperature=0)
# Spécifier explicitement ProviderStrategy
agent = create_agent(
model=model,
response_format=ProviderStrategy(schema=CourseInfo),
system_prompt="Vous êtes l'assistant de cours pour EXAMPLE.",
)
result = agent.invoke({
"messages": [HumanMessage(content="Le tutoriel sur les bases de Python 3 est un cours gratuit pour débutants")]
})
course = result["structured_response"]
print(f"Cours : {course.name}")
print(f"Difficulté : {course.level}")
print(f"Prix : {course.price}")
print(f"\n"Nombre de messages : {len(result['messages'])}") # Moins que ToolStrategy
Sortie :
Course: Python3 基础教程 Difficulty: 入门 Price: 免费 Message count: 2
Comparé à ToolStrategy, ProviderStrategy a moins de messages (2 vs 4) car il ne nécessite pas d'étape supplémentaire d'appel d'outil.
ProviderStrategy est actuellement principalement pris en charge par GPT-4o d'OpenAI et versions supérieures, et Claude 3 et versions supérieures. Si le modèle ne le prend pas en charge, LangChain se rabattra automatiquement sur ToolStrategy. Vous pouvez vérifier si le modèle le prend en charge via model.profile.
AutoStrategy — Sélection automatique
C'est l'approche la plus recommandée. Passez un modèle Pydantic (au lieu d'un objet stratégie), et LangChain sélectionnera automatiquement la meilleure stratégie :
Exemple
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage
class Analysis(BaseModel):
"""Résultat de l'analyse"""
summary: str = Field(description="Résumé en une phrase")
score: int = Field(description="Note 1~10")
pros: list[str] = Field(description="Liste des avantages")
cons: list[str] = Field(description="Liste des inconvénients")
# Passer directement un modèle Pydantic — LangChain sélectionne automatiquement la stratégie
model = init_chat_model("deepseek:deepseek-v4-flash", temperature=0)
agent = create_agent(
model=model,
response_format=Analysis, # Passer directement le modèle ; la stratégie est sélectionnée automatiquement
system_prompt="Vous êtes un expert en évaluation de cours. Évaluez le cours décrit par l'utilisateur.",
)
result = agent.invoke({
"messages": [HumanMessage(
contenu="Cours Python d'EXAMPLE : contenu complet et systématique,"
"riche en exemples et entièrement gratuit. Cependant, les tutoriels vidéo sont limités,"
"et la couverture des contenus avancés est insuffisante."
)]
})
analysis = result["structured_response"]
print(f"Résumé : {analysis.summary}")
print(f"Score : {analysis.score}/10")
print(f"Avantages : {', '.join(analysis.pros)}")
print(f"Inconvénients : {', '.join(analysis.cons)}")
Sortie :
Summary: Example Python 课程内容系统且免费，但缺乏视频教学和高级内容 Rating: 7/10 Pros: 内容系统全面, 实例丰富, 完全免费 Cons: 视频教程较少, 高级内容覆盖不够
Guide pour choisir parmi trois stratégies
| Scénario | Stratégie recommandée | Raison |
|---|---|---|
| Vous n'êtes pas sûr que le modèle prenne en charge la sortie native | AutoStrategy (passer directement Pydantic) | Sélectionne automatiquement la meilleure stratégie |
| Doit être compatible avec divers modèles | ToolStrategy | Fonctionne avec tous les modèles qui prennent en charge l'appel de fonctions |
| Recherche de performances maximales | ProviderStrategy | Saute l'étape d'appel d'outil, plus rapide |
| Nécessite une nouvelle tentative en cas d'erreur | ToolStrategy(handle_errors=True) | Seul ToolStrategy prend en charge handle_errors |
Autres extensionsDans la plupart des cas, passer directement un modèle Pydantic (c'est-à-dire utiliser AutoStrategy) suffit. Ce n'est que lorsque vous avez besoin d'une nouvelle tentative en cas d'erreur ou d'un contrôle explicite du comportement de la stratégie que vous devez spécifier explicitement ToolStrategy ou ProviderStrategy.