#
Utiliser les Agents dans LlamaIndex

Vous vous souvenez d’Alfred, notre agent majordome serviable d’avant ? Eh bien, il va recevoir une mise à niveau ! Maintenant que nous comprenons les tools disponibles dans LlamaIndex, nous pouvons donner à Alfred de nouvelles capacités pour mieux nous servir.

Mais avant de continuer, rappelons-nous ce qui fait fonctionner un agent comme Alfred. Dans l’Unité 1, nous avons appris que :

> Un Agent est un système qui exploite un modèle d’IA pour interagir avec son environnement afin d’atteindre un objectif défini par l’utilisateur. Il combine le raisonnement, la planification et l’exécution d’actions (souvent via des tools externes) pour accomplir des tâches.

LlamaIndex prend en charge trois types principaux d’agents de raisonnement :

1. `Function Calling Agents` - Ceux-ci fonctionnent avec des modèles d’IA qui peuvent appeler des fonctions spécifiques.
2. `ReAct Agents` - Ceux-ci peuvent fonctionner avec n’importe quelle IA qui fait du chat ou des endpoints de texte et traiter des tâches de raisonnement complexes.
3. `Advanced Custom Agents` - Ceux-ci utilisent des méthodes plus complexes pour traiter des tâches et workflows plus complexes.

Trouvez plus d'informations sur les agents avancés sur *BaseWorkflowAgent*

##
Initialiser les Agents

Vous pouvez suivre le code dans ce *notebook* que vous pouvez exécuter avec Google Colab.

Pour créer un agent, nous commençons par lui fournir un ensemble de fonctions/tools qui définissent ses capacités. Regardons comment créer un agent avec quelques tools de base. Au moment de la rédaction, l’agent utilisera automatiquement l’API d’appel de fonctions (si disponible), ou une boucle d’agent ReAct standard.

Les LLMs qui prennent en charge une API tools/fonctions sont relativement nouveaux, mais ils fournissent un moyen puissant d’appeler des tools en évitant le prompting spécifique et permettant au LLM de créer des appels de tools basés sur des schémas fournis.

Les agents ReAct sont également bons pour les tâches de raisonnement complexes et peuvent fonctionner avec n’importe quel LLM qui a des capacités de chat ou de complétion de texte. Ils sont plus verbeux et montrent le raisonnement derrière certaines actions qu’ils prennent.

    from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
    from llama_index.core.agent.workflow import AgentWorkflow
    from llama_index.core.tools import FunctionTool

    # define sample Tool -- type annotations, function names, and docstrings, are all included in parsed schemas!
    def multiply(a: int, b: int) -> int:
        """Multiplies two integers and returns the resulting integer"""
        return a * b

    # initialize llm
    llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")

    # initialize agent
    agent = AgentWorkflow.from_tools_or_functions(
        [FunctionTool.from_defaults(multiply)],
        llm=llm
    )

Les agents sont sans état par défaut, ajouter la mémorisation des interactions passées est optionnel en utilisant un objet `Context` Cela pourrait être utile si vous voulez utiliser un agent qui a besoin de se souvenir des interactions précédentes, comme un chatbot qui maintient le contexte à travers plusieurs messages ou un gestionnaire de tâches qui a besoin de suivre les progrès au fil du temps.

    # stateless
    response = await agent.run("What is 2 times 2?")

    # remembering state
    from llama_index.core.workflow import Context

    ctx = Context(agent)

    response = await agent.run("My name is Bob.", ctx=ctx)
    response = await agent.run("What was my name again?", ctx=ctx)

Vous remarquerez que les agents dans `LlamaIndex` sont asynchrones car ils utilisent l’opérateur `await` de Python. Si vous êtes nouveau au code asynchrone en Python, ou avez besoin d’un rappel, ils ont un excellent guide asynchrone.

Maintenant que nous avons les bases, jetons un coup d’œil à comment nous pouvons utiliser des tools plus complexes dans nos agents.

##
Créer des Agents RAG avec des QueryEngineTools

Le RAG agentique est un moyen puissant d’utiliser des agents pour répondre à des questions sur vos données. Nous pouvons passer divers tools à Alfred pour l’aider à répondre aux questions. Cependant, au lieu de répondre automatiquement à la question au-dessus des documents, Alfred peut décider d’utiliser n’importe quel autre tool ou flux pour répondre à la question.

Il est facile d’envelopper `QueryEngine` comme un tool pour un agent. Ce faisant, nous devons définir un nom et une description. Le LLM utilisera ces informations pour utiliser correctement le tool. Voyons comment charger un `QueryEngineTool` en utilisant le `QueryEngine` que nous avons créé dans la section des components.

    from llama_index.core.tools import QueryEngineTool

    query_engine = index.as_query_engine(llm=llm, similarity_top_k=3) # as shown in the Components in LlamaIndex section

    query_engine_tool = QueryEngineTool.from_defaults(
        query_engine=query_engine,
        name="name",
        description="a specific description",
        return_direct=False,
    )
    query_engine_agent = AgentWorkflow.from_tools_or_functions(
        [query_engine_tool],
        llm=llm,
        system_prompt="You are a helpful assistant that has access to a database containing persona descriptions. "
    )

##
Créer des systèmes multi-agents

La classe `AgentWorkflow` prend également en charge directement les systèmes multi-agents. En donnant à chaque agent un nom et une description, le système maintient un seul speaker actif, chaque agent ayant la capacité de passer le relais à un autre agent.

En rétrécissant la portée de chaque agent, nous pouvons aider à augmenter leur précision générale lors de la réponse aux messages des utilisateurs.

Les agents dans LlamaIndex peuvent également être directement utilisés comme tools pour d’autres agents, pour des scénarios plus complexes et personnalisés.

    from llama_index.core.agent.workflow import (
        AgentWorkflow,
        FunctionAgent,
        ReActAgent,
    )

    # Define some tools
    def add(a: int, b: int) -> int:
        """Add two numbers."""
        return a + b

    def subtract(a: int, b: int) -> int:
        """Subtract two numbers."""
        return a - b

    # Create agent configs
    # NOTE: we can use FunctionAgent or ReActAgent here.
    # FunctionAgent works for LLMs with a function calling API.
    # ReActAgent works for any LLM.
    calculator_agent = ReActAgent(
        name="calculator",
        description="Performs basic arithmetic operations",
        system_prompt="You are a calculator assistant. Use your tools for any math operation.",
        tools=[add, subtract],
        llm=llm,
    )

    query_agent = ReActAgent(
        name="info_lookup",
        description="Looks up information about XYZ",
        system_prompt="Use your tool to query a RAG system to answer information about XYZ",
        tools=[query_engine_tool],
        llm=llm
    )

    # Create and run the workflow
    agent = AgentWorkflow(
        agents=[calculator_agent, query_agent], root_agent="calculator"
    )

    # Run the system
    response = await agent.run(user_msg="Can you add 5 and 3?")

Vous n'avez pas encore assez appris ? Il y a beaucoup plus à découvrir sur les agents et les *tools* dans LlamaIndex dans l'Introduction de base à *AgentWorkflow* ou le *Guide* d'apprentissage des *Agents*, où vous pouvez lire plus sur le *streaming*, la sérialisation de contexte, et l'humain dans la boucle !

Maintenant que nous comprenons les bases des agents et des tools dans LlamaIndex, voyons comment nous pouvons utiliser LlamaIndex pour créer des workflows configurables et gérables !

< > Update on GitHub