Les agents IA deviennent de plus en plus utiles à mesure qu'ils dépassent le simple fait de répondre à des questions pour gérer des tâches de bout en bout. Les Deep Agents de LangChain offrent plus de contrôle et de flexibilité en aidant les agents à décomposer le travail, utiliser différents outils, gérer l'information et coordonner des tâches plus petites. Cela facilite la création d'agents capables de gérer des workflows concrets sans nécessiter une supervision constante. Voyons comment fonctionnent les Deep Agents de LangChain et ce qu'il est possible de construire avec eux.
Que sont les Deep Agents de LangChain ?
Les Deep Agents de LangChain sont un framework d'agents construit sur les briques de base de LangChain et le runtime LangGraph. Ils étendent les workflows d'agents standard avec des capacités intégrées telles que l'accès au système de fichiers, la délégation à des sous-agents, la planification, la mémoire et la prise en charge de l'intervention humaine. Les Deep Agents utilisent une boucle d'agent qui combine raisonnement, appel d'outils et exécution itérative, ce qui les rend adaptés aux tâches complexes nécessitant plusieurs étapes, de grandes quantités de contexte et des workflows coordonnés.
Contrairement aux agents basiques qui se contentent principalement d'appeler des outils dans une boucle simple, les Deep Agents fournissent une infrastructure supplémentaire pour gérer les tâches de longue durée. Ils peuvent gérer des fichiers, déléguer du travail à des sous-agents spécialisés, maintenir le contexte au fil de workflows complexes et permettre une intervention humaine lorsque nécessaire. Ces capacités intégrées réduisent la quantité d'ingénierie sur mesure nécessaire lors de la création de systèmes d'agents avancés.
Comment fonctionnent les Deep Agents de LangChain
Lorsqu'un Deep Agent reçoit une tâche, il analyse la demande et planifie les étapes nécessaires pour l'accomplir. Il utilise ensuite les outils disponibles, tels que la recherche, l'exécution de code ou les opérations sur le système de fichiers, pour rassembler des informations et effectuer des actions.
Pendant l'exécution, les Deep Agents gèrent le contexte en lisant et en écrivant des fichiers. Au lieu de conserver tous les résultats intermédiaires dans l'historique de la conversation, ils peuvent stocker de grandes quantités d'informations à l'extérieur et les récupérer en cas de besoin. Cette approche aide les agents à gérer des workflows plus longs tout en réduisant les limitations liées à la taille de la fenêtre de contexte.
Pour les tâches complexes impliquant plusieurs domaines de travail, les Deep Agents peuvent déléguer des sous-tâches spécifiques à des sous-agents spécialisés. Chaque sous-agent se concentre sur un objectif défini et renvoie les résultats pertinents à l'agent principal. L'agent principal combine ensuite les résultats des sous-agents, les informations récupérées et les fichiers stockés pour générer une réponse complète et cohérente.
Grâce à des fonctionnalités telles que la planification, l'utilisation d'outils, la gestion du système de fichiers, la collaboration entre sous-agents et la supervision humaine, les Deep Agents de LangChain offrent une base pour créer des systèmes IA plus performants capables de gérer des tâches concrètes en plusieurs étapes.
Capacités fondamentales des Deep Agents : planification, outils et exécution
Les Deep Agents peuvent gérer des tâches nécessitant plusieurs étapes, décisions et actions. Leurs fonctionnalités principales les aident à planifier le travail, utiliser les outils adaptés et accomplir chaque étape efficacement avec moins d'intervention manuelle. Examinons ces capacités en détail :
Planification des tâches
La planification des tâches permet aux agents de créer et de gérer une liste de tâches structurée pendant l'exécution. Plutôt que de traiter un objectif complexe comme une instruction unique, les agents peuvent le diviser en étapes plus petites, suivre les progrès et mettre à jour le statut des tâches au fil du workflow.
Quand utiliser la planification
Tâches longues ou complexes comportant plusieurs étapes
Tâches qui bénéficient d'un suivi explicite des progrès et d'une exécution structurée
Interfaces utilisateur qui diffusent en continu la progression depuis l'état de l'agent
Comment l'activer
Passez TodoListMiddleware au paramètre middleware. Cela donne à l'agent un outil write_todos permettant de maintenir une liste de tâches structurée avec suivi du statut (pending, in_progress, completed).
from deepagents import create_deep_agent
from deepagents.middleware import TodoListMiddleware
agent = create_deep_agent(
model="your-model",
middleware=[TodoListMiddleware()],
)Les tâches sont conservées dans l'état de l'agent, ce qui lui offre une couche de planification légère pour organiser le travail de longue durée.
Outils de système de fichiers virtuel
Les Deep Agents fournissent un système de fichiers virtuel configurable, adossé à des backends interchangeables : état en mémoire, disque local, magasin LangGraph, routage composite, ou backends personnalisés avec règles de permission.
Outils de système de fichiers intégrés
| Outil | Description |
|---|---|
ls | Liste les fichiers d'un répertoire avec leurs métadonnées (taille, date de modification) |
read_file | Lit le contenu d'un fichier avec les numéros de ligne ; prend en charge un offset/une limite pour les fichiers volumineux ; renvoie également des blocs de contenu multimodal pour les images, vidéos, fichiers audio et documents |
write_file | Crée un nouveau fichier ou remplace un fichier existant |
edit_file | Effectue des remplacements exacts de chaînes dans les fichiers (avec un mode de remplacement global) |
delete | Supprime un fichier ou un répertoire de manière récursive |
glob | Recherche des fichiers correspondant à des motifs (par exemple, **/*.py) |
grep | Recherche dans le contenu des fichiers avec plusieurs modes de sortie |
execute | Exécute des commandes shell dans l'environnement (backends sandbox uniquement) |
Extensions multimodales prises en charge
Image :
.png,.jpg,.jpeg,.gif,.webp,.heic,.heifVidéo :
.mp4,.mpeg,.mov,.avi,.flv,.mpg,.webm,.wmv,.3gppAudio :
.wav,.mp3,.aiff,.aac,.ogg,.flacDocument :
.pdf,.ppt,.pptx
Permissions du système de fichiers
Le harness prend en charge des règles de permission déclaratives qui contrôlent les fichiers et répertoires que l'agent peut lire ou écrire. Les règles sont évaluées de haut en bas, la première correspondance l'emportant.
from deepagents import create_deep_agent
agent = create_deep_agent(
model="anthropic:your-model",
permissions=[
{"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
{"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
],
)from deepagents import create_deep_agent
agent = create_deep_agent(
model="anthropic:your-model",
permissions=[
{"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
{"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
],
)Cela vous permet de restreindre les agents à des répertoires spécifiques, de protéger les fichiers sensibles et de donner aux subagents un accès plus restreint que celui de l'agent parent.
Restreindre l'accès aux outils
Vous pouvez exposer uniquement un sous-ensemble des outils du système de fichiers en passant une liste blanche tools à FilesystemMiddleware. read_file doit toujours être inclus.
from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware
# Read-only agent
agent = create_deep_agent(
model="your-model",
middleware=[
FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
],
)from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware
# Read-only agent
agent = create_deep_agent(
model="your-model",
middleware=[
FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
],
)Subagents (délégation)
Le harness inclut un outil intégré task qui permet à l'agent principal de créer des subagents éphémères pour des tâches isolées, longues, à étapes multiples ou parallèles.
Caractéristiques principales
Contexte neuf : Chaque invocation crée une nouvelle instance d'agent avec son propre contexte
Exécution autonome : Le subagent s'exécute de manière indépendante jusqu'à son achèvement
Remise unique : Il renvoie un seul rapport final à l'agent principal
Stratégie configurable : Utilisez le subagent
general-purposepar défaut ou définissez des subagents personnalisésEfficacité de contexte : Le travail lourd des sous-tâches reste isolé et est compressé en un résultat compact
Désactiver les subagents
Pour exécuter un agent sans l'outil task, désactivez le subagent ajouté automatiquement via le profil du harness et ne passez aucun subagent synchrone via subagents=. N'essayez pas de retirer SubAgentMiddleware via excluded_middleware — cela est intentionnellement rejeté.
Capacités d'appel d'outils
Les Deep Agents prennent en charge trois catégories d'outils :
Fonctions personnalisées et outils LangChain
Passez des fonctions personnalisées ou des outils LangChain directement via le paramètre tools= :
MCP (Model Context Protocol)
Les Deep Agents prennent entièrement en charge le MCP, ce qui vous permet de vous connecter à des bases de données, des API, des systèmes de fichiers et plus encore via une interface standard.
Exécution de code
Backends sandbox : exposez un outil
executepour exécuter des commandes shell dans un environnement isoléInterpréteurs : ajoutez un outil
evalqui exécute du JavaScript dans un runtime QuickJS restreint pour des couches programmables légères
Lorsque ces capacités se combinent, le modèle de langage qui alimente l'agent devient un élément important de l'ensemble du dispositif. Un modèle performant peut aider les Deep Agents à comprendre les instructions, à raisonner sur les tâches et à mieux utiliser les outils à leur disposition. Le Kimi API peut fournir cette couche de modèle, ce qui en fait une étape naturelle pour construire des workflows Deep Agent plus performants.
Connecter Kimi API aux Deep Agents de LangChain en 6 étapes
Un modèle performant donne à votre Deep Agent la compréhension du langage et le raisonnement nécessaires pour traiter les tâches efficacement. Kimi API peut fournir ces capacités pendant que l'agent utilise des outils, gère des tâches et traite des instructions complexes. Une fois cette couche de modèle en place, la mise en place peut naturellement se poursuivre en connectant Kimi API aux LangChain Agents. Voici comment connecter Kimi API aux LangChain Deep Agents :
Étape 1 : obtenez votre clé API Kimi
Connectez-vous à la plateforme Kimi API et créez une nouvelle clé API. Copiez-la et conservez-la en lieu sûr, car vous devrez l'ajouter à votre configuration Deep Agents. Cette clé API authentifie vos requêtes et permet aux Deep Agents de LangChain d'accéder aux modèles Kimi via l'API.
Étape 2 : définissez les variables d'environnement
Définissez votre clé API Kimi comme variable d'environnement. Le Kimi API utilise le point de terminaison de l'API Moonshot, configurez donc la variable suivante :
export MOONSHOT_API_KEY="your-api-key-here"export MOONSHOT_API_KEY="your-api-key-here"L'URL de base de l'API est :
https://api.moonshot.ai/v1https://api.moonshot.ai/v1Étape 3 : installez les dépendances
Installez Deep Agents et les dépendances LangChain requises :
pip install deepagents langchain-openai
``````bash
pip install deepagents langchain-openaiComme le Kimi API est compatible avec OpenAI, langchain-openai permet à LangChain de se connecter aux modèles Kimi via l'interface compatible OpenAI.
Si vous souhaitez ajouter des capacités de recherche web à votre Deep Agent, vous pouvez éventuellement installer Tavily :
pip install tavily-pythonpip install tavily-pythonAprès avoir créé une clé API Tavily sur la plateforme Tavily, définissez-la comme variable d'environnement :
export TAVILY_API_KEY="your-tavily-api-key"export TAVILY_API_KEY="your-tavily-api-key"Tavily n'est nécessaire que si vous prévoyez d'ajouter des outils de recherche web à votre agent.
Étape 4 : configurez un Deep Agent avec Kimi API
Comme le Kimi API est compatible avec le format de l'API OpenAI, vous pouvez le connecter aux Deep Agents de LangChain via init_chat_model.
L'exemple suivant crée un Deep Agent basique alimenté par Kimi. Vous pouvez éventuellement l'étendre avec des outils tels que la recherche web.
Deep Agent basique alimenté par Kimi
Ajouter des capacités de recherche web (facultatif)
Pour activer la recherche web, connectez un outil de recherche tel que Tavily :
Avec cette configuration, les Deep Agents peuvent utiliser Kimi comme modèle de raisonnement tout en accédant à des capacités de recherche externes via Tavily.
Étape 5 : exécutez votre Deep Agent alimenté par Kimi
Une fois votre Deep Agent configuré avec Kimi, exécutez-le pour vérifier comment il traite les tâches et les appels d'outils.
result = agent.invoke(
{"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)
print(result["messages"][-1].content)result = agent.invoke(
{"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)
print(result["messages"][-1].content)Étape 6 : activez le traçage LangSmith (facultatif)
Le traçage LangSmith vous aide à surveiller l'exécution de l'agent, y compris les appels d'outils, les étapes intermédiaires et les réponses du modèle.
Activez le traçage avec les variables d'environnement suivantes :
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"Utilisez LangSmith lorsque vous avez besoin d'une visibilité plus approfondie sur les workflows de l'agent, le débogage ou l'analyse des performances.
Avantages de l'utilisation de Kimi API
Connecter Kimi API aux Deep Agents peut rendre les workflows complexes plus performants et plus faciles à gérer. Cette combinaison donne aux agents un raisonnement plus solide tout en leur permettant d'utiliser des outils, de gérer des fichiers et de traiter plusieurs tâches. Voici les principaux avantages qu'offre cette configuration :
Améliorer le raisonnement de l'agent et l'exécution des tâches
Les modèles Kimi offrent une compréhension du langage et un raisonnement solides, aidant les Deep Agents à analyser des instructions complexes, à décomposer des tâches et à générer des réponses plus précises. Cela permet aux agents de gérer des workflows en plusieurs étapes plus efficacement avec moins d'intervention manuelle.
Construire des workflows IA plus performants
Avec Kimi API connecté aux Deep Agents, les développeurs peuvent combiner les capacités des modèles Kimi avec les outils, les systèmes de fichiers et les intégrations externes prises en charge par LangChain. Cela permet aux agents d'effectuer des tâches telles que la recherche, le traitement de documents, l'analyse de code et la gestion de données au sein d'un workflow unifié.
Faire évoluer des tâches complexes avec des agents autonomes
Les Deep Agents alimentés par Kimi peuvent gérer des tâches de longue durée en créant des plans, en utilisant des outils et en déléguant des sous-tâches si nécessaire. Cela facilite la création d'applications d'IA capables d'accomplir des workflows complexes tout en réduisant les opérations manuelles répétitives.
Conclusion
Créer des agents IA fiables commence par le choix de la bonne base pour des workflows complexes. LangChain Deep Agents fournit les outils et la structure nécessaires pour créer des agents capables de planifier, d'utiliser des outils, de gérer le contexte et de traiter des tâches à plusieurs étapes avec moins d'effort manuel. Avec le bon modèle et la bonne configuration, les développeurs peuvent transformer des idées d'agents avancés en applications concrètes. En intégrant l'API Kimi, vous pouvez encore renforcer vos workflows Deep Agent grâce à des capacités de raisonnement solides et de contexte long. Commencez à explorer l'API Kimi et découvrez ce que vous pouvez créer avec des agents IA.