Systèmes multi-agents avec Mistral AI, Milvus et Llama-agents

Objectif de ce carnet

Dans ce carnet, nous allons explorer différentes idées :

• 1️⃣ Stocker des données dans Milvus : Apprendre à stocker des données dans Milvus, une base de données vectorielle efficace conçue pour les recherches de similarité à grande vitesse et les applications d'IA.

• 2️⃣ Utiliser llama-index avec les modèles Mistral pour les requêtes de données : Découvrez comment utiliser llama-index en combinaison avec les modèles Mistral pour interroger les données stockées dans Milvus.

• 3️⃣ Créer des agents automatisés de recherche et de lecture de données : Construire des agents capables de rechercher et de lire automatiquement des données en fonction des requêtes de l'utilisateur. Ces agents automatisés amélioreront l'expérience de l'utilisateur en fournissant des réponses rapides et précises, réduisant ainsi les efforts de recherche manuelle.

• 4️⃣ Développer des agents pour le filtrage des métadonnées sur la base des requêtes des utilisateurs : mettre en œuvre des agents capables de générer automatiquement des filtres de métadonnées à partir des requêtes des utilisateurs, afin d'affiner et de contextualiser les résultats de la recherche, d'éviter les confusions et d'améliorer la précision des informations récupérées, même pour les requêtes complexes.

• A la fin de ce carnet, vous aurez une compréhension complète de l'utilisation de Milvus, llama-index avec llama-agents, et des modèles Mistral pour construire un système de recherche de données robuste et efficace.

Milvus

Milvus est une base de données vectorielle open-source qui alimente les applications d'intelligence artificielle avec des embeddings vectoriels et des recherches de similarité.

Dans ce carnet, nous utilisons Milvus Lite, qui est la version allégée de Milvus.

Avec Milvus Lite, vous pouvez commencer à construire une application d'IA avec la recherche de similarité vectorielle en quelques minutes ! Milvus Lite peut être exécuté dans les environnements suivants :

• Jupyter Notebook / Google Colab
• Ordinateurs portables
• Périphériques Edge

image.png

llama-agents

llama-agents permet d'exécuter des agents en tant que microservices. Il est ainsi possible de faire évoluer les services à la hausse ou à la baisse.

llama-index

LlamaIndex est un cadre de données pour votre application LLM. Il fournit des outils tels que :

• Les connecteurs de données ingèrent vos données existantes à partir de leur source et de leur format natifs.
• Les index de données structurent vos données dans des représentations intermédiaires qui sont faciles et performantes pour les LLM.
• Les moteurs fournissent un accès en langage naturel à vos données.
• Les agents sont des travailleurs de la connaissance alimentés par des LLM et complétés par des outils, allant de simples fonctions d'aide à des intégrations d'API et plus encore.

image.png

Mistral AI

Mistral AI est un laboratoire de recherche qui construit des LLM et des Embeddings Models. Ils ont récemment publié de nouvelles versions de leurs modèles, Mistral Nemo et Mistral Large, qui se sont révélés particulièrement performants dans RAG et l'appel de fonctions. C'est pourquoi nous allons les utiliser dans ce carnet.

Installer les dépendances

$ pip install llama-agents pymilvus openai python-dotenv

$ pip install llama-index-vector-stores-milvus llama-index-readers-file llama-index-llms-ollama llama-index-llms-mistralai llama-index-embeddings-mistralai

# NOTE: This is ONLY necessary in jupyter notebook.
# Details: Jupyter runs an event-loop behind the scenes.
#          This results in nested event-loops when we start an event-loop to make async queries.
#          This is normally not allowed, we use nest_asyncio to allow it for convenience.
import nest_asyncio

nest_asyncio.apply()

Obtenez votre clé API pour Mistral

Vous pouvez obtenir la clé API de Mistral à partir de la console cloud de Mistral.

"""
load_dotenv reads key-value pairs from a .env file and can set them as environment variables.
This is useful to avoid leaking your API key for example :D
"""

from dotenv import load_dotenv
import os

load_dotenv()

True

Télécharger les données

$ mkdir -p 'data/10k/'
$ wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/uber_2021.pdf' -O 'data/10k/uber_2021.pdf'
$ wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/10k/lyft_2021.pdf' -O 'data/10k/lyft_2021.pdf'

Préparer le modèle d'intégration

Nous définissons le modèle d'intégration qui sera utilisé dans ce carnet. Nous utilisons mistral-embed, c'est un modèle d'intégration développé par Mistral, il a été entraîné avec les Retrievals à l'esprit, ce qui en fait un très bon modèle pour notre système Agentic RAG. Pour plus de détails, veuillez vous référer à la page Embedding sur la documentation Mistral.

from llama_index.core import Settings
from llama_index.embeddings.mistralai import MistralAIEmbedding

# Define the default Embedding model used in this Notebook.
# We are using Mistral Models, so we are also using Mistral Embeddings

Settings.embed_model = MistralAIEmbedding(model_name="mistral-embed")

Définir le modèle LLM

Llama Index utilise des LLM pour répondre aux invites et aux requêtes, et est responsable de l'écriture des réponses en langage naturel. Nous définissons Mistral Nemo comme le modèle par défaut. Nemo offre une large fenêtre contextuelle pouvant aller jusqu'à 128k tokens. Son raisonnement, sa connaissance du monde et sa précision de codage sont à la pointe de la technologie dans sa catégorie de taille.

from llama_index.llms.ollama import Ollama

Settings.llm = Ollama("mistral-nemo")

Instancier Milvus et charger les données

Milvus est une base de données vectorielle open-source populaire qui alimente les applications d'IA avec une recherche de similarité vectorielle hautement performante et évolutive.

• Définir l'uri comme un fichier local, par exemple./milvus.db, est la méthode la plus pratique, car elle utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier.
• Si vous disposez de données à grande échelle, par exemple plus d'un million de vecteurs, vous pouvez configurer un serveur Milvus plus performant sur Docker ou Kubernetes. Dans cette configuration, veuillez utiliser l'uri du serveur, par exemplehttp://localhost:19530, comme uri.
• Si vous souhaitez utiliser Zilliz Cloud, le service cloud entièrement géré pour Milvus, ajustez l'uri et le token, qui correspondent au point final public et à la clé API dans Zilliz Cloud.

from llama_index.vector_stores.milvus import MilvusVectorStore
from llama_index.core import (
    SimpleDirectoryReader,
    VectorStoreIndex,
    StorageContext,
    load_index_from_storage,
)
from llama_index.core.tools import QueryEngineTool, ToolMetadata

input_files = ["./data/10k/lyft_2021.pdf", "./data/10k/uber_2021.pdf"]

# Create a single Milvus vector store
vector_store = MilvusVectorStore(
    uri="./milvus_demo.db", dim=1024, overwrite=False, collection_name="companies_docs"
)

# Create a storage context with the Milvus vector store
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Load data
docs = SimpleDirectoryReader(input_files=input_files).load_data()

# Build index
index = VectorStoreIndex.from_documents(docs, storage_context=storage_context)

# Define the query engine
company_engine = index.as_query_engine(similarity_top_k=3)

Définir les outils

L'une des étapes clés de la création d'un agent efficace consiste à définir les outils qu'il peut utiliser pour accomplir ses tâches. Ces outils sont essentiellement des fonctions ou des services auxquels l'agent peut faire appel pour récupérer des informations ou effectuer des actions.

Ci-dessous, nous allons définir deux outils que notre agent peut utiliser pour demander des informations financières sur Lyft et Uber à partir de l'année 2021. Ces outils seront intégrés à notre agent, ce qui lui permettra de répondre à des requêtes en langage naturel avec des informations précises et pertinentes.

Si vous regardez le graphique que nous avons en haut, voici ce qu'est un "service d'agent".

# Define the different tools that can be used by our Agent.
query_engine_tools = [
    QueryEngineTool(
        query_engine=company_engine,
        metadata=ToolMetadata(
            name="lyft_10k",
            description=(
                "Provides information about Lyft financials for year 2021. "
                "Use a detailed plain text question as input to the tool."
                "Do not attempt to interpret or summarize the data."
            ),
        ),
    ),
    QueryEngineTool(
        query_engine=company_engine,
        metadata=ToolMetadata(
            name="uber_10k",
            description=(
                "Provides information about Uber financials for year 2021. "
                "Use a detailed plain text question as input to the tool."
                "Do not attempt to interpret or summarize the data."
            ),
        ),
    ),
]

from llama_index.llms.ollama import Ollama
from llama_index.llms.mistralai import MistralAI

# Set up the agent
llm = Ollama(model="mistral-nemo")

response = llm.predict_and_call(
    query_engine_tools,
    user_msg="Could you please provide a comparison between Lyft and Uber's total revenues in 2021?",
    allow_parallel_tool_calls=True,
)

# Example usage without metadata filtering
print("Response without metadata filtering:")
print(response)

Response without metadata filtering:
The revenue for Lyft in 2021 was $3.84 billion.

Uber's total revenue for the year ended December 31, 2021 was $17,455 million.

Filtrage des métadonnées

Milvus prend en charge le filtrage des métadonnées, une technique qui vous permet d'affiner et de réduire les résultats de la recherche en fonction d'attributs ou de balises spécifiques associés à vos données. Cette technique est particulièrement utile dans les scénarios où vous disposez d'un grand nombre de données et où vous devez récupérer uniquement le sous-ensemble de données correspondant à certains critères.

Cas d'utilisation du filtrage des métadonnées

• Précision des résultats de recherche: En appliquant des filtres de métadonnées, vous pouvez vous assurer que les résultats de la recherche sont très pertinents par rapport à la requête de l'utilisateur. Par exemple, si vous disposez d'une collection de documents financiers, vous pouvez les filtrer en fonction du nom de la société, de l'année ou de toute autre métadonnée pertinente.

• Efficacité: Le filtrage des métadonnées permet de réduire la quantité de données à traiter, ce qui rend les opérations de recherche plus efficaces. C'est particulièrement utile lorsqu'il s'agit d'ensembles de données volumineux.

• Personnalisation: Différents utilisateurs ou applications peuvent avoir des exigences différentes. Le filtrage des métadonnées vous permet de personnaliser les résultats de la recherche pour répondre à des besoins spécifiques, tels que la récupération de documents d'une année ou d'une entreprise particulière.

Exemple d'utilisation

Dans le bloc de code ci-dessous, le filtrage des métadonnées est utilisé pour créer un moteur de recherche filtré qui récupère les documents sur la base d'une paire clé-valeur de métadonnées spécifique : file_name: lyft_2021.pdf

Le QueryEngineTool défini ci-dessous est plus générique que celui défini ci-dessus, dans ce dernier, nous avions un outil par entreprise (Uber et Lyft), dans celui-ci, il est plus générique. En ajoutant un filtre de métadonnées, nous pouvons alors filtrer pour obtenir uniquement les données d'un document spécifique.

from llama_index.core.vector_stores import ExactMatchFilter, MetadataFilters

# Example usage with metadata filtering
filters = MetadataFilters(
    filters=[ExactMatchFilter(key="file_name", value="lyft_2021.pdf")]
)

print(f"filters: {filters}")
filtered_query_engine = index.as_query_engine(filters=filters)

# Define query engine tools with the filtered query engine
query_engine_tools = [
    QueryEngineTool(
        query_engine=filtered_query_engine,
        metadata=ToolMetadata(
            name="company_docs",
            description=(
                "Provides information about various companies' financials for year 2021. "
                "Use a detailed plain text question as input to the tool."
                "Use this tool to retrieve specific data points about a company. "
                "Do not attempt to interpret or summarize the data."
            ),
        ),
    ),
]

filters: filters=[MetadataFilter(key='file_name', value='lyft_2021.pdf', operator=<FilterOperator.EQ: '=='>)] condition=<FilterCondition.AND: 'and'>

Appel de fonction

Mistral Nemo et Large supportent l'appel de fonction natif. Il y a une intégration transparente avec les outils LlamaIndex, par le biais de la fonction predict_and_call sur le LLM. Cela permet à l'utilisateur d'attacher n'importe quel outil et de laisser le LLM décider quels outils appeler (le cas échéant).

Pour en savoir plus sur les agents, consultez le site Web de llama-index.

# Set up the LLM we will use for Function Calling

llm = Ollama(model="mistral-nemo")

Interagir avec l'agent

Nous pouvons maintenant voir le filtrage des métadonnées en action :

1. Dans le premier cas, l'agent ne devrait rien trouver pour répondre à la requête de l'utilisateur puisqu'elle concerne Uber et que nous filtrons uniquement les documents relatifs à Lyft.
2. Dans le second, l'agent devrait pouvoir trouver des informations sur Lyft car nous ne recherchons que les documents qui concernent Lyft.

response = llm.predict_and_call(
    query_engine_tools,
    user_msg="How many employees does Uber have?",
    allow_parallel_tool_calls=True,
)
print(response)

I'm unable to provide information about Uber's employee count as it's outside the given Lyft context.

response = llm.predict_and_call(
    query_engine_tools,
    user_msg="What are the risk factors for Lyft?",
    allow_parallel_tool_calls=True,
)

print(response)

Investing in Lyft carries significant risks. These include general economic factors like impacts from pandemics or crises, operational factors such as competition, pricing changes, and driver/ride growth unpredictability, insurance coverage issues, autonomous vehicle technology uncertainties, reputational concerns, potential security breaches, reliance on third-party services, and challenges in expanding platform offerings. Lyft's business operations are subject to numerous other risks not explicitly mentioned here, which could also harm its financial condition and prospects.

Exemple de confusion sans filtrage des métadonnées

> Question: What are the risk factors for Uber?

> Response without metadata filtering:
Based on the provided context, which pertains to Lyft's Risk Factors section in their Annual Report, some of the potential risk factors applicable to a company like Uber might include:

- General economic factors such as the impact of global pandemics or other crises on ride-sharing demand.
- Operational factors like competition in ride-hailing services, unpredictability in results of operations, and uncertainty about market growth for ridesharing and related services.
- Risks related to attracting and retaining qualified drivers and riders.

Dans cet exemple, le système fournit à tort des informations sur Lyft au lieu d'Uber, ce qui entraîne une réponse trompeuse. Il commence par dire qu'il ne dispose pas de l'information, puis continue.

Utilisation d'un agent pour extraire les filtres de métadonnées

Pour résoudre ce problème, nous pouvons utiliser un agent pour extraire automatiquement les filtres de métadonnées de la question de l'utilisateur et les appliquer pendant le processus de réponse à la question. Cela permet de s'assurer que le système récupère les informations correctes et pertinentes.

Exemple de code

L'exemple de code ci-dessous montre comment créer un moteur de requêtes filtrées en utilisant un agent pour extraire les filtres de métadonnées de la question de l'utilisateur :

Explication

• Modèle d'invite: La classe PromptTemplate est utilisée pour définir un modèle d'extraction des filtres de métadonnées à partir de la question de l'utilisateur. Le modèle indique au modèle linguistique de prendre en compte les noms d'entreprises, les années et d'autres attributs pertinents.

• LLM: Mistral Nemo est utilisé pour générer les filtres de métadonnées sur la base de la question de l'utilisateur. Le modèle est invité à utiliser la question et le modèle pour extraire les filtres pertinents.

• Filtres de métadonnées: La réponse du LLM est analysée pour créer un objet MetadataFilters. Si aucun filtre spécifique n'est mentionné, un objet MetadataFilters vide est renvoyé.

• Moteur de requête filtré: la méthode index.as_query_engine(filters=metadata_filters) crée un moteur de requête qui applique les filtres de métadonnées extraits à l'index. Cela garantit que seuls les documents correspondant aux critères de filtrage sont récupérés.

from llama_index.core.prompts.base import PromptTemplate


# Function to create a filtered query engine
def create_query_engine(question):
    # Extract metadata filters from question using a language model
    prompt_template = PromptTemplate(
        "Given the following question, extract relevant metadata filters.\n"
        "Consider company names, years, and any other relevant attributes.\n"
        "Don't write any other text, just the MetadataFilters object"
        "Format it by creating a MetadataFilters like shown in the following\n"
        "MetadataFilters(filters=[ExactMatchFilter(key='file_name', value='lyft_2021.pdf')])\n"
        "If no specific filters are mentioned, returns an empty MetadataFilters()\n"
        "Question: {question}\n"
        "Metadata Filters:\n"
    )

    prompt = prompt_template.format(question=question)
    llm = Ollama(model="mistral-nemo")
    response = llm.complete(prompt)

    metadata_filters_str = response.text.strip()
    if metadata_filters_str:
        metadata_filters = eval(metadata_filters_str)
        print(f"eval: {metadata_filters}")
        return index.as_query_engine(filters=metadata_filters)
    return index.as_query_engine()

response = create_query_engine(
    "What is Uber revenue? This should be in the file_name: uber_2021.pdf"
)

eval: filters=[MetadataFilter(key='file_name', value='uber_2021.pdf', operator=<FilterOperator.EQ: '=='>)] condition=<FilterCondition.AND: 'and'>

## Example usage with metadata filtering
question = "What is Uber revenue? This should be in the file_name: uber_2021.pdf"
filtered_query_engine = create_query_engine(question)

# Define query engine tools with the filtered query engine
query_engine_tools = [
    QueryEngineTool(
        query_engine=filtered_query_engine,
        metadata=ToolMetadata(
            name="company_docs_filtering",
            description=(
                "Provides information about various companies' financials for year 2021. "
                "Use a detailed plain text question as input to the tool."
            ),
        ),
    ),
]
# Set up the agent with the updated query engine tools
response = llm.predict_and_call(
    query_engine_tools,
    user_msg=question,
    allow_parallel_tool_calls=True,
)

print("Response with metadata filtering:")
print(response)

eval: filters=[MetadataFilter(key='file_name', value='uber_2021.pdf', operator=<FilterOperator.EQ: '=='>)] condition=<FilterCondition.AND: 'and'>
Response with metadata filtering:
Uber's total revenue for the year ended December 31, 2021, is $17.455 billion.

Orchestrer les différents services avec Mistral Large

Mistral Large est le modèle phare de Mistral avec de très bonnes capacités de raisonnement, de connaissance et de codage. Il est idéal pour les tâches complexes qui nécessitent de grandes capacités de raisonnement ou qui sont hautement spécialisées. Il possède des capacités d'appel de fonctions avancées, ce qui est exactement ce dont nous avons besoin pour orchestrer nos différents agents.

Pourquoi avons-nous besoin d'un modèle plus intelligent ?

La question à laquelle nous répondons ci-dessous est particulièrement difficile car elle nécessite l'orchestration de plusieurs services et agents afin de fournir une réponse cohérente et précise. Cela implique la coordination de divers outils et agents pour récupérer et traiter des informations provenant de différentes sources, telles que des données financières provenant de différentes entreprises.

Qu'y a-t-il de si difficile dans tout cela ?

• La complexité : La question implique de multiples agents et services, chacun avec ses propres fonctionnalités et sources de données. Coordonner ces agents pour qu'ils travaillent ensemble de manière transparente est une tâche complexe.

• Intégration des données : La question nécessite l'intégration de données provenant de différentes sources, ce qui peut s'avérer difficile en raison des variations dans les formats, les structures et les métadonnées des données.

• Compréhension du contexte : La question peut nécessiter de comprendre le contexte et les relations entre différents éléments d'information, ce qui est une tâche cognitivement exigeante.

Pourquoi Mistral Large serait-il utile dans ce cas ?

Mistral Large est bien adapté à cette tâche grâce à ses capacités avancées de raisonnement et d'appel de fonctions. Voici en quoi il est utile :

• Raisonnement avancé : Mistral Large peut gérer des tâches de raisonnement complexes, ce qui le rend idéal pour orchestrer plusieurs agents et services. Il peut comprendre les relations entre différents éléments d'information et prendre des décisions éclairées.

• Capacités d'appel de fonctions : Mistral Large possède des capacités avancées d'appel de fonctions, qui sont essentielles pour coordonner les actions de différents agents. Cela permet une intégration et une orchestration transparentes de divers services.

• Connaissances spécialisées : Mistral Large est conçu pour des tâches hautement spécialisées, ce qui le rend bien adapté au traitement de requêtes complexes nécessitant une connaissance approfondie du domaine.

Pour toutes ces raisons, j'ai décidé qu'il était préférable d'utiliser Mistral Large plutôt que Mistral Nemo.

from llama_agents import (
    AgentService,
    ToolService,
    LocalLauncher,
    MetaServiceTool,
    ControlPlaneServer,
    SimpleMessageQueue,
    AgentOrchestrator,
)

from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.llms.mistralai import MistralAI

# create our multi-agent framework components
message_queue = SimpleMessageQueue()
control_plane = ControlPlaneServer(
    message_queue=message_queue,
    orchestrator=AgentOrchestrator(llm=MistralAI("mistral-large-latest")),
)

# define Tool Service
tool_service = ToolService(
    message_queue=message_queue,
    tools=query_engine_tools,
    running=True,
    step_interval=0.5,
)

# define meta-tools here
meta_tools = [
    await MetaServiceTool.from_tool_service(
        t.metadata.name,
        message_queue=message_queue,
        tool_service=tool_service,
    )
    for t in query_engine_tools
]

# define Agent and agent service
worker1 = FunctionCallingAgentWorker.from_tools(
    meta_tools, llm=MistralAI("mistral-large-latest")
)

agent1 = worker1.as_agent()
agent_server_1 = AgentService(
    agent=agent1,
    message_queue=message_queue,
    description="Used to answer questions over differnet companies for their Financial results",
    service_name="Companies_analyst_agent",
)

import logging

# change logging level to enable or disable more verbose logging
logging.getLogger("llama_agents").setLevel(logging.INFO)

## Define Launcher
launcher = LocalLauncher(
    [agent_server_1, tool_service],
    control_plane,
    message_queue,
)

query_str = "What are the risk factors for Uber?"
result = launcher.launch_single(query_str)

INFO:llama_agents.message_queues.simple - Consumer AgentService-27cde4ed-5163-4005-90fc-13c158eda7e3: Companies_analyst_agent has been registered.
INFO:llama_agents.message_queues.simple - Consumer ToolService-b73c500a-5fbe-4f57-95c7-db74e173bd1b: default_tool_service has been registered.
INFO:llama_agents.message_queues.simple - Consumer 62465ab8-32ff-436e-95fa-74e828745150: human has been registered.
INFO:llama_agents.message_queues.simple - Consumer ControlPlaneServer-f4c27d43-5474-43ca-93ca-a9aeed4534d7: control_plane has been registered.
INFO:llama_agents.services.agent - Companies_analyst_agent launch_local
INFO:llama_agents.message_queues.base - Publishing message to 'control_plane' with action 'ActionTypes.NEW_TASK'
INFO:llama_agents.message_queues.simple - Launching message queue locally
INFO:llama_agents.services.agent - Processing initiated.
INFO:llama_agents.services.tool - Processing initiated.
INFO:llama_agents.message_queues.base - Publishing message to 'Companies_analyst_agent' with action 'ActionTypes.NEW_TASK'
INFO:llama_agents.message_queues.simple - Successfully published message 'control_plane' to consumer.
INFO:llama_agents.services.agent - Created new task: 0720da2f-1751-4766-a814-ba720bc8a467
INFO:llama_agents.message_queues.simple - Successfully published message 'Companies_analyst_agent' to consumer.
INFO:llama_agents.message_queues.simple - Consumer MetaServiceTool-5671c175-7b03-4bc8-b60d-bd7101d0fc41: MetaServiceTool-5671c175-7b03-4bc8-b60d-bd7101d0fc41 has been registered.
INFO:llama_agents.message_queues.base - Publishing message to 'default_tool_service' with action 'ActionTypes.NEW_TOOL_CALL'
INFO:llama_agents.message_queues.simple - Successfully published message 'default_tool_service' to consumer.
INFO:llama_agents.services.tool - Processing tool call id f4c270a4-bc47-4bbf-92fe-e2cc80757943 with company_docs
INFO:llama_agents.message_queues.base - Publishing message to 'control_plane' with action 'ActionTypes.COMPLETED_TASK'
INFO:llama_agents.message_queues.base - Publishing message to 'MetaServiceTool-5671c175-7b03-4bc8-b60d-bd7101d0fc41' with action 'ActionTypes.COMPLETED_TOOL_CALL'
INFO:llama_agents.message_queues.base - Publishing message to 'Companies_analyst_agent' with action 'ActionTypes.NEW_TASK'
INFO:llama_agents.message_queues.simple - Successfully published message 'control_plane' to consumer.
INFO:llama_agents.message_queues.simple - Successfully published message 'MetaServiceTool-5671c175-7b03-4bc8-b60d-bd7101d0fc41' to consumer.
INFO:llama_agents.services.agent - Created new task: 0720da2f-1751-4766-a814-ba720bc8a467
INFO:llama_agents.message_queues.simple - Successfully published message 'Companies_analyst_agent' to consumer.
INFO:llama_agents.message_queues.base - Publishing message to 'default_tool_service' with action 'ActionTypes.NEW_TOOL_CALL'
INFO:llama_agents.message_queues.simple - Successfully published message 'default_tool_service' to consumer.
INFO:llama_agents.services.tool - Processing tool call id f888f9a8-e716-4505-bfe2-577452e9b6e6 with company_docs
INFO:llama_agents.message_queues.base - Publishing message to 'MetaServiceTool-5671c175-7b03-4bc8-b60d-bd7101d0fc41' with action 'ActionTypes.COMPLETED_TOOL_CALL'
INFO:llama_agents.message_queues.simple - Successfully published message 'MetaServiceTool-5671c175-7b03-4bc8-b60d-bd7101d0fc41' to consumer.
INFO:llama_agents.message_queues.base - Publishing message to 'control_plane' with action 'ActionTypes.COMPLETED_TASK'
INFO:llama_agents.message_queues.base - Publishing message to 'human' with action 'ActionTypes.COMPLETED_TASK'
INFO:llama_agents.message_queues.simple - Successfully published message 'control_plane' to consumer.
INFO:llama_agents.message_queues.simple - Successfully published message 'human' to consumer.

print(result)

[{"name": "finalize", "arguments": {"input": "Uber faces several risk factors, including general economic impacts such as pandemics or downturns, operational challenges like competition, market growth uncertainty, attracting and retaining drivers and riders, insurance adequacy, autonomous vehicle technology development, maintaining its reputation and brand, and managing growth. Additionally, reliance on third-party providers for various services can introduce further risks to its operations."}}]

Conclusion

Dans ce carnet, vous avez vu comment vous pouvez utiliser les agents Lama pour effectuer différentes actions en appelant les outils appropriés. En utilisant Mistral Large en combinaison avec Mistral Nemo, nous avons démontré comment orchestrer efficacement des systèmes intelligents et économes en ressources en exploitant les forces de différents LLM. Nous avons vu que l'agent pouvait choisir la collection contenant les données demandées par l'utilisateur.