Sistemas multiagente con Mistral AI, Milvus y Llama-agents

Objetivo de este cuaderno

En este Cuaderno exploraremos diferentes ideas:

• 1️⃣ Almacenar datos en Milvus: Aprender a almacenar datos en Milvus, una eficiente base de datos vectorial diseñada para búsquedas de similitud de alta velocidad y aplicaciones de IA.

• 2️⃣ Utilizar llama-index con modelos Mistral para consultas de datos: Descubra cómo utilizar llama-index en combinación con modelos Mistral para consultar datos almacenados en Milvus.

• 3️⃣ Crear Agentes Automatizados de Búsqueda y Lectura de Datos: Construir agentes que puedan buscar y leer datos automáticamente basándose en las consultas de los usuarios. Estos agentes automatizados mejorarán la experiencia del usuario al ofrecer respuestas rápidas y precisas, reduciendo el esfuerzo de búsqueda manual.

• 4️⃣ Desarrollar agentes para el filtrado de metadatos basado en consultas de usuario: Implementar agentes que puedan generar automáticamente filtros de metadatos a partir de consultas de usuario, refinando y contextualizando los resultados de búsqueda, evitando confusiones y mejorando la precisión de la información recuperada, incluso para consultas complejas.

• 🔍 Resumen Al final de este cuaderno, tendrás una comprensión completa del uso de Milvus, llama-index con llama-agentes y modelos Mistral para construir un sistema de recuperación de datos robusto y eficiente.

Milvus

Milvus es una base de datos vectorial de código abierto que potencia las aplicaciones de IA con incrustaciones vectoriales y búsqueda de similitudes.

En este cuaderno, utilizamos Milvus Lite, que es la versión ligera de Milvus.

Con Milvus Lite, ¡puede empezar a crear una aplicación de IA con búsqueda de similitud vectorial en cuestión de minutos! Milvus Lite es bueno para ejecutarse en el siguiente entorno:

• Jupyter Notebook / Google Colab
• Portátiles
• Dispositivos Edge

imagen.png

llama-agentes

llama-agents permite ejecutar agentes como microservicios. Esto permite ampliar y reducir los servicios.

llama-index

LlamaIndex es un framework de datos para tu aplicación LLM. Proporciona herramientas como:

• Los conectores de datos ingieren tus datos existentes desde su fuente y formato nativos.
• Los índices de datos estructuran tus datos en representaciones intermedias que son fáciles y eficaces de consumir para los LLM.
• Los motores proporcionan acceso en lenguaje natural a sus datos.
• Los agentes son trabajadores del conocimiento potenciados por LLM y aumentados por herramientas, desde simples funciones de ayuda a integraciones API y más.

imagen.png

Mistral AI

Mistral AI es un laboratorio de investigación que construye modelos LLM y Embeddings. Recientemente han lanzado nuevas versiones de sus modelos, Mistral Nemo y Mistral Large, que han demostrado ser particularmente buenos en RAG y llamada a funciones. Por ello, vamos a utilizarlos en este cuaderno.

Instalar dependencias

$ 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()

Obtenga su clave API para Mistral

Puede obtener la clave API de Mistral desde la Consola en la Nube 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

Descargar datos

$ 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'

Preparar Embedding Model

Definimos el Embedding Model que se utilizará en este cuaderno. Nosotros usamos mistral-embed, es un modelo de Embedding desarrollado por Mistral, ha sido entrenado con Retrievals en mente, lo que lo hace muy bueno para nuestro sistema Agentic RAG. Para más detalles, consulta la página de Embedding en la Documentación de 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")

Definir el modelo LLM

Llama Index utiliza LLMs para responder a prompts y consultas, y se encarga de escribir las respuestas en lenguaje natural. Definimos Mistral Nemo como el predeterminado. Nemo ofrece una gran ventana de contexto de hasta 128k tokens. Su razonamiento, conocimiento del mundo y precisión de codificación son los más avanzados en su categoría de tamaño.

from llama_index.llms.ollama import Ollama

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

Instalar Milvus y cargar datos

Milvus es una popular base de datos vectorial de código abierto que potencia las aplicaciones de IA con una búsqueda de similitud vectorial escalable y de alto rendimiento.

• Establecer la uri como un archivo local, por ejemplo./milvus.db, es el método más conveniente, ya que utiliza automáticamente Milvus Lite para almacenar todos los datos en este archivo.
• Si tiene una gran escala de datos, digamos más de un millón de vectores, puede configurar un servidor Milvus más eficiente en Docker o Kubernetes. En esta configuración, por favor utilice la uri del servidor, por ejemplohttp://localhost:19530, como su uri.
• Si desea utilizar Zilliz Cloud, el servicio en la nube totalmente gestionado para Milvus, ajuste la uri y el token, que se corresponden con el Public Endpoint y la clave API en 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)

Definir herramientas

Uno de los pasos clave en la construcción de un agente eficaz es definir las herramientas que puede utilizar para realizar sus tareas. Estas herramientas son esencialmente funciones o servicios a los que el agente puede llamar para recuperar información o realizar acciones.

A continuación, definiremos dos herramientas que nuestro agente puede utilizar para consultar información financiera sobre Lyft y Uber a partir del año 2021. Estas herramientas se integrarán en nuestro agente, permitiéndole responder a consultas en lenguaje natural con información precisa y relevante.

Si nos fijamos en el gráfico que tenemos en la parte superior, esto es lo que es un "Servicio de Agente".

# 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.

Filtrado de Metadatos

Milvus admite el filtrado de metadatos, una técnica que le permite refinar y reducir los resultados de la búsqueda basándose en atributos o etiquetas específicos asociados a sus datos. Esto es particularmente útil en situaciones en las que tiene muchos datos y necesita recuperar sólo el subconjunto relevante de datos que coincide con ciertos criterios.

Casos prácticos del filtrado de metadatos

• Precisión en los resultados de búsqueda: Al aplicar filtros de metadatos, puede asegurarse de que los resultados de la búsqueda sean muy pertinentes para la consulta del usuario. Por ejemplo, si tiene una colección de documentos financieros, puede filtrarlos en función del nombre de la empresa, el año o cualquier otro metadato relevante.

• Eficacia: El filtrado de metadatos ayuda a reducir la cantidad de datos que hay que procesar, haciendo que las operaciones de búsqueda sean más eficientes. Esto es especialmente beneficioso cuando se trata de grandes conjuntos de datos.

• Personalización: Los distintos usuarios o aplicaciones pueden tener necesidades diferentes. El filtrado de metadatos permite personalizar los resultados de la búsqueda para satisfacer necesidades específicas, como recuperar documentos de un año o una empresa concretos.

Ejemplo de uso

En el siguiente bloque de código, el filtrado de metadatos se utiliza para crear un motor de consulta filtrado que recupera documentos basándose en un par clave-valor de metadatos específico: file_name: lyft_2021.pdf

El QueryEngineTool definido a continuación es más genérico que el definido anteriormente, en el anterior, teníamos una herramienta por empresa (Uber y Lyft), en este, es más genérico. Sólo sabemos que tenemos documentos financieros sobre empresas, pero nada más. Añadiendo un Filtrado de Metadatos, podemos filtrar para obtener sólo los datos de un documento concreto.

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'>

Llamada a funciones

Mistral Nemo y Large soportan llamadas a funciones nativas. Hay una integración perfecta con las herramientas LlamaIndex, a través de la función predict_and_call en el llm. Esto permite al usuario adjuntar cualquier herramienta y dejar que el LLM decida qué herramientas llamar (si las hay).

Puede obtener más información sobre los Agentes en el sitio web de LlamaIndex.

# Set up the LLM we will use for Function Calling

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

Interactuar con el Agente

Ahora podemos ver el Filtrado de Metadatos en acción:

1. En la primera, el Agente no debería ser capaz de encontrar nada a la consulta del usuario ya que se trata de Uber y filtramos en Documentos sólo sobre Lyft.
2. En el segundo, el Agente debería ser capaz de encontrar información sobre Lyft ya que sólo buscaremos en documentos que sean sobre 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.

Ejemplo de confusión sin filtrado de metadatos

> 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.

En este ejemplo, el sistema proporciona incorrectamente información sobre Lyft en lugar de Uber, lo que conduce a una respuesta engañosa. Empieza diciendo que no tiene la información, pero luego sigue y sigue.

Utilizar un agente para extraer filtros de metadatos

Para solucionar este problema, podemos utilizar un agente que extraiga automáticamente los filtros de metadatos de la pregunta del usuario y los aplique durante el proceso de respuesta a la pregunta. Esto garantiza que el sistema recupere la información correcta y relevante.

Ejemplo de código

A continuación se muestra un ejemplo de código que demuestra cómo crear un motor de consultas filtradas utilizando un agente para extraer filtros de metadatos de la pregunta del usuario:

Explicación

• Plantilla Prompt: La clase PromptTemplate se utiliza para definir una plantilla para extraer filtros de metadatos de la pregunta del usuario. La plantilla indica al modelo lingüístico que tenga en cuenta los nombres de las empresas, los años y otros atributos relevantes.

• LLM: Mistral Nemo se utiliza para generar los filtros de metadatos a partir de la pregunta del usuario. El modelo recibe la pregunta y la plantilla para extraer los filtros pertinentes.

• Filtros de metadatos: La respuesta del LLM se analiza para crear un objeto MetadataFilters. Si no se mencionan filtros específicos, se devuelve un objeto MetadataFilters vacío.

• Motor de consultafiltrado: El método index.as_query_engine(filters=metadata_filters) crea un motor de consulta que aplica al índice los filtros de metadatos extraídos. Esto garantiza que sólo se recuperen los documentos que coincidan con los criterios de filtrado.

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.

Orquestación de los distintos servicios con Mistral Large

Mistral Large es el modelo insignia de Mistral con muy buenas capacidades de razonamiento, conocimiento y codificación. Es ideal para tareas complejas que requieren grandes capacidades de razonamiento o son altamente especializadas. Tiene capacidades avanzadas de llamada a funciones, que es exactamente lo que necesitamos para orquestar nuestros diferentes agentes.

¿Por qué necesitamos un modelo más inteligente?

La pregunta que se responde a continuación es especialmente difícil porque requiere la orquestación de múltiples servicios y agentes para ofrecer una respuesta coherente y precisa. Esto implica coordinar varias herramientas y agentes para recuperar y procesar información de distintas fuentes, como datos financieros de distintas empresas.

¿Qué tiene eso de difícil?

• La complejidad: La cuestión implica múltiples agentes y servicios, cada uno con su propia funcionalidad y fuentes de datos. Coordinar estos agentes para que trabajen juntos sin problemas es una tarea compleja.

• Integración de datos: La pregunta requiere integrar datos de distintas fuentes, lo que puede suponer un reto debido a las variaciones en los formatos, estructuras y metadatos de los datos.

• Comprensión del contexto: La pregunta puede requerir la comprensión del contexto y las relaciones entre diferentes piezas de información, lo cual es una tarea cognitivamente exigente.

¿Por qué sería útil Mistral Large en este caso?

Mistral Large se adapta bien a esta tarea gracias a sus capacidades avanzadas de razonamiento y de llamada a funciones. He aquí cómo ayuda:

• Razonamiento avanzado: Mistral Large puede manejar tareas de razonamiento complejas, lo que lo hace ideal para orquestar múltiples agentes y servicios. Puede entender las relaciones entre diferentes piezas de información y tomar decisiones informadas.

• Capacidades de llamada a funciones: Mistral Large tiene capacidades avanzadas de llamada a funciones, que son esenciales para coordinar las acciones de diferentes agentes. Esto permite una integración y orquestación perfectas de varios servicios.

• Conocimientos especializados: Mistral Large está diseñado para tareas altamente especializadas, por lo que es muy adecuado para manejar consultas complejas que requieren un profundo conocimiento del dominio.

Por todas estas razones, decidí que utilizar Mistral Large en lugar de Mistral Nemo era más adecuado en este caso.

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."}}]

Conclusión

En este cuaderno, has visto cómo puedes utilizar llama-agentes para realizar diferentes acciones llamando a las herramientas apropiadas. Mediante el uso de Mistral Large en combinación con Mistral Nemo, hemos demostrado cómo orquestar eficazmente sistemas inteligentes y eficientes en recursos aprovechando los puntos fuertes de diferentes LLM. Vimos que el Agente podía elegir la colección que contenía los datos solicitados por el usuario.