Accueil / Articles

Appel d’outils dans LangChain : le mécanisme sous-jacent aux applications agnitives

Enregistrez les fonctions Python en tant qu’outils LangChain et exécutez la boucle à quatre étapes où le modèle sélectionne des outils, ceux-ci s’exécutent en externe et les résultats reviennent sous forme de messages.

Éditeur : REACTAPP.TOP6 min de lecture1280 mots

Sources: Agentic AI with LangChain — Part 3: Tool Calling in LangChain

Ce est la troisième partie de la série « L’IA agente avec LangChain ». La deuxième partie a mis en place un flux de travail RAG agent avec LangGraph. L’étape suivante consiste à étendre ce système à davantage de domaines : la cuisine, la natation, la musique classique, et même les prévisions météorologiques en direct pour des villes du monde entier, sans submerger le graphe de nouveaux nœuds.

En suivant le modèle de la deuxième partie, on pourrait ajouter un nœud de récupération par domaine, chacun disposant de son propre index Pinecone, ainsi qu’un nœud météo qui fait appel à une API publique. À mesure que les nœuds se multiplient, les connexions et les branches augmentent également, rendant le graphe difficile à gérer.

L’appel d’outils constitue la solution idéale. Au lieu d’avoir un nœud par fonction, enregistrez ces fonctions comme des outils LangChain et laissez le modèle décider quand les appeler, comment utiliser leurs résultats et comment les intégrer dans la réponse finale. Cela simplifie le flux de travail et permet d’élargir les capacités du modèle grâce à des calculs précis, des requêtes de base de données, des recherches sur le web et des API en temps réel.

Ce qui suit présente les idées fondamentales ainsi que le cycle d’appel d’outils dans LangChain. Ces bases préparent l’article suivant consacré à ReAct. Une fois ReAct compris, le flux de travail de la partie 2 peut être simplifié en utilisant les mêmes principes. Le code se trouve dans le dépôt GitHub.

Sujets :

  • Qu’est-ce que l’appel d’outils et pourquoi est-il important ?
  • Comment implémenter des outils LangChain.
  • Comment fonctionne le cycle d’appel d’outils en quatre étapes.

Vocabulaire

  • Outil LangChain : une fonction Python décorée avec @tool qui expose son schéma et ses instructions d’utilisation au modèle.
  • Appel d’outil : le mécanisme par lequel le modèle demande l’exécution d’une fonction externe.
  • Message d’outil : le type de message qui ramène les résultats de l’outil au modèle.
  • Boucle d’appel d’outil : le cycle dans lequel le modèle sélectionne un outil, l’outil s’exécute en dehors du modèle, les résultats reviennent et le modèle les intègre dans la réponse.

Mise en place

Créez un fichier .env contenant les clés OpenAI et Tavily.

OPENAI_API_KEY="<Your OpenAI API Key>"
TAVILY_API_KEY=<Your TAVILY API Key>

Chargez-les à l’aide d’une classe de configuration Pydantic.

class BaseConfig(BaseSettings):
    OPENAI_API_KEY: Optional[str]
    PINECONE_API_KEY: Optional[str]
    TAVILY_API_KEY: Optional[str]

model_config = SettingsConfigDict(env_file=".env", extra="ignore")

Le projet conserve les outils dans un package tools, avec des exemples simples tels qu’un outil de calcul de somme et un outil météo.

project/
|
├── tools
│   ├── get_sum.py    # a simple LangChain tool example
|   └── weather.py    # get_weather LangChain tool using open source APIs
|
|── tool_call.py      # implement tool-calling loop using LangChain tools
├── config.py         # pydantic BaseConfig
├── .env              # environment variable definition
├── .gitignore
└── requirements.txt  # package requirements

Qu’est-ce qu’un outil LangChain

Un outil est une fonction Python ordinaire munie du décorateur @tool. Ce décorateur enrobe la fonction, crée un schéma à partir de la documentation et des indications de type, et fournit au modèle des instructions pour l’appeler.

from langchain.tools import tool


@tool
def get_sum(a: int, b: int) -> int:
    """
    get the summation of two integers
    :param a: int, input integer
    :param b: int, input integer
    :return: int, the sum of a and b
    """
    return a + b

Outil météorologique

get_weather utilise l’API gratuite Open-Meteo. Il cherche les coordonnées d’une ville, puis récupère les conditions météorologiques actuelles. Ce schéma, d’abord résoudre puis récupérer, est typique des outils en temps réel.

Le cycle d’appel des outils

Lorsque les outils existent, la question suivante est de savoir comment le modèle les utilise. La réponse est un cycle en quatre étapes.

  1. L’utilisateur envoie une demande.
  2. Le modèle décide quel ou quels outils appeler et émet un message contenant les noms et les arguments.
  3. Les outils s’exécutent en dehors du modèle, et leurs résultats reviennent sous forme de messages d’outil.
  4. Le modèle intègre ces résultats et produit une réponse finale.

Le modèle ne met jamais lui-même en exécution les outils. Tout s’exécute externement, et les sorties reviennent sous forme de messages d’outil que le modèle analyse ensuite.

Le modèle peut également demander plusieurs outils dans une seule réponse, ce qu’on appelle des appels d’outils en parallèle. Lorsqu’on lui demande la température à Boston ainsi que la somme de trois et cinq, il peut exécuter à la fois get_weather et get_sum ; la boucle les exécute tous deux avant de répondre.

Mettre en œuvre la boucle dans LangChain

Une classe WeatherAssistant regroupe les fonctionnalités de prévision météorologique et de recherche sur le web en utilisant get_weather et tavily_search.

LLM et outils

Le constructeur configure un modèle OpenAI, un dictionnaire des outils, un LLM capable de les appeler, une liste de messages ainsi qu’un prompt système indiquant au modèle quand utiliser chaque outil.

class WeatherAssistant:
    def __init__(self):

        # initialize llm
        self.llm = ChatOpenAI(api_key=api_key, model="gpt-4o-mini", temperature=0)

        # initialize a tool dictionary
        self.tools = {"get_weather": get_weather,
                      "tavily_search": TavilySearch(max_results=3, tavily_api_key=TAVILY_API_KEY)}
        # bind LangChain tools to llm
        self.llm_with_tools = self.llm.bind_tools(list(self.tools.values()))

        # initialize messages to store message list
        self.messages = []

        # System prompt
        self.system_prompt = f"""You are a helpful assistant for question-answering tasks.
        When users ask about weather, use the get_weather tool to get weather. For other questions,
        use web_search. If you don't know the answer, just say that you don't know.
        Be conversational and helpful in your responses."""

        self.messages.append(SystemMessage(content=self.system_prompt))

La méthode de chat

chat ajoute le message de l’utilisateur, invoque le modèle, et si des appels d’outils sont présents, exécute chaque outil en boucle, ajoute chacun des résultats sous forme de ToolMessage, puis invoque à nouveau le modèle pour obtenir la réponse finale. Ce schéma gère aussi bien les appels simples que ceux en parallèle.

async def chat(self, message: str):
    # Wrap User message in a HumanMessage and add it to message list
    self.messages.append(HumanMessage(content=message))

    # Get AI response (it may or may not contain tool calls)
    response = await self.llm_with_tools.ainvoke(self.messages)
    self.messages.append(response)

    # If there is any tool calls in the AI response
    if response.tool_calls:

        # process tool calls
        for tool_call in response.tool_calls:

            # retrieve function name from tool_call, then
            # retrieve the tool from tool dictionary, and invoke it,
            # append resulting tool message to message list
            tool = self.tools[tool_call["name"]]
            tool_result = await tool.ainvoke(tool_call)
            self.messages.append(tool_result)

        # Get final response after tool execution
        final_response = await self.llm_with_tools.ainvoke(self.messages)
        self.messages.append(final_response)

Un test rapide

Un petit programme principal asynchrone crée l’assistant et demande la température à Tokyo.

async def main():
    print("hello tool calling!")
    assistant = WeatherAssistant()
    message = "What is the temperature in Tokyo?"
    await assistant.chat(message)
    for msg in assistant.messages:
        msg.pretty_print()
if __name__ == "__main__":
    asyncio.run(main())

La liste des messages montre alors une séquence claire : un message humain contenant la question, un message d’IA avec une appel à l’outil get_weather, un message de l’outil contenant les données météorologiques, et enfin un message d’IA avec la réponse orale.

Remarque sur les erreurs et les tentatives de réessai\n\nSi un outil génère une exception, la boucle doit capturer cette erreur, la transformer en un message d’outil clair, et laisser le modèle décider s’il faut réessayer ou s’excuser. Des tentatives de réessai aveugles avec les mêmes arguments erronés sont une perte de temps ; il vaut mieux afficher le texte d’erreur afin que le modèle puisse s’adapter.\n\n## Pourquoi c’est important pour la série

L’appel d’outil est le mécanisme de base sous-jacent à ReAct ainsi qu’à tout agent qui décide de ses propres actions. Une fois ce cycle bien établi, ajouter une nouvelle capacité signifie simplement écrire une autre fonction @tool plutôt qu’un nouveau nœud du graphe. C’est la simplification dont le flux de travail complexe de la Partie 2 avait besoin. Une fois les outils enregistrés, les nouveaux domaines cessent d’être des nœuds du graphe pour devenir de nouvelles fonctions que le modèle peut découvrir à partir de leurs schémas et de leurs documents d’aide. Le prochain article développe ce cycle avec le pattern ReAct, avant de revenir au graphe de la Partie 2 pour montrer à quel point les connexions disparaissent lorsque c’est l’appel d’outil qui prend en charge les décisions.