Sistemas Multi-agentes com Mistral AI, Milvus e Llama-agents

Objetivo deste Caderno

Neste Notebook, vamos explorar diferentes ideias:

• 1️⃣ Armazenar dados no Milvus: Aprenda a armazenar dados no Milvus, um banco de dados vetorial eficiente projetado para pesquisas de similaridade de alta velocidade e aplicativos de IA.

• 2️⃣ Utilizar o llama-index com modelos Mistral para consultas de dados: Descubra como utilizar o llama-index em combinação com modelos Mistral para consultar dados armazenados no Milvus.

• 3️⃣ Criar agentes automatizados de pesquisa e leitura de dados: Crie agentes que possam pesquisar e ler dados automaticamente com base em consultas do utilizador. Estes agentes automatizados melhorarão a experiência do utilizador ao fornecer respostas rápidas e precisas, reduzindo o esforço de pesquisa manual.

• 4️⃣ Desenvolver agentes para filtragem de metadados com base em consultas do utilizador: Implementar agentes que possam gerar automaticamente filtros de metadados a partir de consultas do utilizador, refinando e contextualizando os resultados da pesquisa, evitando confusões e melhorando a precisão das informações recuperadas, mesmo para consultas complexas.

• Resumo No final deste caderno, terá uma compreensão abrangente da utilização de Milvus, llama-index com llama-agents e modelos Mistral para construir um sistema de recuperação de dados robusto e eficiente.

Milvus

O Milvus é uma base de dados vetorial de código aberto que potencia as aplicações de IA com embeddings vectoriais e pesquisa de semelhanças.

Neste caderno, utilizamos o Milvus Lite, que é a versão mais leve do Milvus.

Com o Milvus Lite, pode começar a construir uma aplicação de IA com pesquisa de semelhanças vectoriais em poucos minutos! O Milvus Lite é bom para ser executado nos seguintes ambientes:

• Jupyter Notebook / Google Colab
• Computadores portáteis
• Dispositivos Edge

image.png

llama-agentes

llama-agents torna possível executar agentes como microsserviços. Isso torna possível escalar serviços para cima e para baixo.

llama-index

LlamaIndex é um framework de dados para sua aplicação LLM. Ele fornece ferramentas como:

• Conectores de dados ingerem seus dados existentes a partir de sua fonte e formato nativos.
• Índices de dados estruturam seus dados em representações intermediárias que são fáceis e eficientes para os LLMs consumirem.
• Motores que fornecem acesso em linguagem natural aos seus dados.
• Os agentes são trabalhadores do conhecimento com base em LLMs, aumentados por ferramentas, desde simples funções auxiliares até integrações de APIs e muito mais.

image.png

Mistral AI

A Mistral AI é um laboratório de investigação que constrói LLMs e Embeddings Models. Recentemente, lançaram novas versões dos seus modelos, Mistral Nemo e Mistral Large, que se revelaram particularmente bons em RAG e chamadas de função. Por isso, vamos usá-los neste caderno

Instalar dependências

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

Obtenha sua chave de API para o Mistral

Você pode obter a chave da API Mistral no Mistral Cloud Console.

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

Baixar dados

$ 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 modelo de incorporação

Definimos o modelo de incorporação que será usado neste notebook. Usamos mistral-embed, é um modelo de incorporação desenvolvido pela Mistral, que foi treinado com as recuperações em mente, o que o torna muito bom para o nosso sistema Agentic RAG. Para mais pormenores, consulte a página Embedding na documentação da 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 o modelo LLM

O Llama Index usa LLMs para responder a prompts e consultas, e é responsável por escrever respostas em linguagem natural. Definimos o Mistral Nemo como o padrão. O Nemo oferece uma grande janela de contexto de até 128k tokens. O seu raciocínio, conhecimento do mundo e precisão de codificação são os mais avançados na sua categoria de tamanho.

from llama_index.llms.ollama import Ollama

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

Instanciar o Milvus e carregar dados

O Milvus é um popular banco de dados vetorial de código aberto que alimenta aplicativos de IA com pesquisa de similaridade vetorial escalável e de alto desempenho.

• Definir o uri como um ficheiro local, por exemplo,./milvus.db, é o método mais conveniente, uma vez que utiliza automaticamente o Milvus Lite para armazenar todos os dados neste ficheiro.
• Se tiver uma grande escala de dados, digamos mais de um milhão de vectores, pode configurar um servidor Milvus mais eficiente em Docker ou Kubernetes. Nesta configuração, utilize o uri do servidor, por exemplo,http://localhost:19530, como o seu uri.
• Se pretender utilizar o Zilliz Cloud, o serviço de nuvem totalmente gerido para o Milvus, ajuste o uri e o token, que correspondem ao Public Endpoint e à chave API no 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 ferramentas

Um dos principais passos na construção de um agente eficaz é a definição das ferramentas que este pode utilizar para executar as suas tarefas. Estas ferramentas são essencialmente funções ou serviços que o agente pode invocar para obter informações ou executar acções.

De seguida, definiremos duas ferramentas que o nosso agente pode utilizar para consultar informações financeiras sobre a Lyft e a Uber a partir do ano 2021. Estas ferramentas serão integradas no nosso agente, permitindo-lhe responder a consultas em linguagem natural com informações precisas e relevantes.

Se olhar para o gráfico que temos no topo, isto é o que é um "Serviço 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.

Filtragem de metadados

O Milvus suporta a filtragem de metadados, uma técnica que permite refinar e restringir os resultados da pesquisa com base em atributos específicos ou etiquetas associadas aos seus dados. Isto é particularmente útil em cenários em que tem muitos dados e precisa de recuperar apenas o subconjunto relevante de dados que corresponde a determinados critérios.

Casos de utilização da filtragem de metadados

• Precisão nos resultados da pesquisa: Ao aplicar filtros de metadados, pode garantir que os resultados da pesquisa são altamente relevantes para a consulta do utilizador. Por exemplo, se tiver uma coleção de documentos financeiros, pode filtrá-los com base no nome da empresa, ano ou quaisquer outros metadados relevantes.

• Eficiência: A filtragem de metadados ajuda a reduzir a quantidade de dados que têm de ser processados, tornando as operações de pesquisa mais eficientes. Isto é especialmente benéfico quando se lida com grandes conjuntos de dados.

• Personalização: Diferentes utilizadores ou aplicações podem ter requisitos diferentes. A filtragem de metadados permite-lhe personalizar os resultados da pesquisa para satisfazer necessidades específicas, como a recuperação de documentos de um determinado ano ou empresa.

Exemplo de utilização

No bloco de código abaixo, a filtragem de metadados é utilizada para criar um motor de pesquisa filtrado que recupera documentos com base num par chave-valor de metadados específico: file_name: lyft_2021.pdf

O QueryEngineTool definido abaixo é mais genérico do que o definido acima. No anterior, tínhamos uma ferramenta por empresa (Uber e Lyft), neste, é mais genérico. Só sabemos que temos documentos financeiros sobre as empresas, mas é só isso. Ao adicionar um filtro de metadados, podemos filtrar para obter apenas dados de um documento específico.

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

Chamada de funções

Mistral Nemo e Large suportam chamadas de funções nativas. Há uma integração perfeita com as ferramentas LlamaIndex, através da função predict_and_call no llm. Isso permite que o usuário anexe qualquer ferramenta e deixe o LLM decidir quais ferramentas chamar (se houver).

Pode saber mais sobre os Agentes no sítio Web do llama-index.

# Set up the LLM we will use for Function Calling

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

Interagir com o agente

Agora podemos ver a Filtragem de Metadados em ação:

1. Na primeira, o agente não deve conseguir encontrar nada para a consulta do utilizador, uma vez que se trata da Uber e filtramos apenas documentos sobre a Lyft.
2. Na segunda, o agente deve conseguir encontrar informações sobre a Lyft, uma vez que só pesquisamos documentos sobre a 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.

Exemplo de confusão sem filtragem de metadados

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

Neste exemplo, o sistema fornece incorretamente informações sobre a Lyft em vez da Uber, o que leva a uma resposta enganadora. Começa por dizer que não tem a informação, mas depois continua.

Utilizar um agente para extrair filtros de metadados

Para resolver este problema, podemos utilizar um agente para extrair automaticamente filtros de metadados da pergunta do utilizador e aplicá-los durante o processo de resposta à pergunta. Isso garante que o sistema recupere as informações corretas e relevantes.

Exemplo de código

Abaixo está um exemplo de código que demonstra como criar um motor de consulta filtrada utilizando um agente para extrair filtros de metadados da pergunta do utilizador:

Explicação

• Modelo de prompt: A classe PromptTemplate é utilizada para definir um modelo para extrair filtros de metadados da pergunta do utilizador. O modelo dá instruções ao modelo de linguagem para considerar nomes de empresas, anos e outros atributos relevantes.

• LLM: Mistral Nemo é utilizado para gerar os filtros de metadados com base na pergunta do utilizador. O modelo é solicitado com a pergunta e o modelo para extrair os filtros relevantes.

• Filtros de metadados: A resposta do LLM é analisada para criar um objeto MetadataFilters. Se não forem mencionados filtros específicos, é devolvido um objeto MetadataFilters vazio.

• Motor de consulta filtrado: O método index.as_query_engine(filters=metadata_filters) cria um motor de consulta que aplica os filtros de metadados extraídos ao índice. Isto garante que apenas são recuperados os documentos que correspondem aos critérios de filtragem.

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.

Orquestração dos diferentes serviços com Mistral Large

O Mistral Large é o modelo principal do Mistral, com muito boas capacidades de raciocínio, conhecimento e codificação. É ideal para tarefas complexas que exigem grandes capacidades de raciocínio ou são altamente especializadas. Possui recursos avançados de chamada de função, que é exatamente o que precisamos para orquestrar nossos diferentes agentes.

Porque é que precisamos de um modelo mais inteligente?

A pergunta que está a ser respondida abaixo é particularmente desafiadora porque requer a orquestração de vários serviços e agentes para fornecer uma resposta coerente e precisa. Isto envolve a coordenação de várias ferramentas e agentes para obter e processar informações de diferentes fontes, como dados financeiros de diferentes empresas.

O que é que isso tem de tão difícil?

• A complexidade: A questão envolve vários agentes e serviços, cada um com a sua própria funcionalidade e fontes de dados. Coordenar estes agentes para que trabalhem em conjunto e sem problemas é uma tarefa complexa.

• Integração de dados: A pergunta requer a integração de dados de diferentes fontes, o que pode ser um desafio devido às variações nos formatos, estruturas e metadados dos dados.

• Compreensão contextual: A pergunta pode exigir a compreensão do contexto e das relações entre diferentes informações, o que é uma tarefa cognitivamente exigente.

Por que é que o Mistral Large ajudaria neste caso?

O Mistral Large é adequado para essa tarefa devido aos seus recursos avançados de raciocínio e chamada de função. Aqui está como isso ajuda:

• Raciocínio avançado: O Mistral Large pode lidar com tarefas complexas de raciocínio, tornando-o ideal para orquestrar vários agentes e serviços. Ele pode entender as relações entre diferentes informações e tomar decisões informadas.

• Recursos de chamada de função: O Mistral Large possui recursos avançados de chamada de função, essenciais para coordenar as ações de diferentes agentes. Isso permite a integração e orquestração perfeitas de vários serviços.

• Conhecimento especializado: O Mistral Large foi projetado para tarefas altamente especializadas, tornando-o adequado para lidar com consultas complexas que exigem profundo conhecimento de domínio.

Por todos esses motivos, decidi que usar o Mistral Large em vez do Mistral Nemo era mais adequado aqui.

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

Conclusão

Neste caderno, viu como pode utilizar agentes Llama para realizar diferentes acções, chamando as ferramentas adequadas. Ao usar o Mistral Large em combinação com o Mistral Nemo, demonstramos como orquestrar efetivamente sistemas inteligentes e eficientes em termos de recursos, aproveitando os pontos fortes de diferentes LLMs. Vimos que o agente pode escolher a coleção que contém os dados solicitados pelo utilizador.