Multiagentensysteme mit Mistral AI, Milvus und Llama-Agenten

Ziel dieses Notebooks

In diesem Notizbuch werden wir verschiedene Ideen untersuchen:

• 1️⃣ Daten in Milvus speichern: Lernen Sie, Daten in Milvus zu speichern, einer effizienten Vektor-Datenbank, die für schnelle Ähnlichkeitssuchen und KI-Anwendungen entwickelt wurde.

• 2️⃣ llama-index mit Mistral-Modellen für Datenabfragen verwenden: Entdecken Sie, wie Sie llama-index in Kombination mit Mistral-Modellen verwenden können, um in Milvus gespeicherte Daten abzufragen.

• 3️⃣ Automatisierte Datensuch- und -lese-Agenten erstellen: Erstellen Sie Agenten, die automatisch Daten auf der Grundlage von Benutzeranfragen suchen und lesen können. Diese automatisierten Agenten verbessern die Benutzerfreundlichkeit, indem sie schnelle und genaue Antworten liefern und den manuellen Suchaufwand reduzieren.

• 4️⃣ Entwicklung von Agenten für die Metadatenfilterung auf der Grundlage von Benutzeranfragen: Implementierung von Agenten, die automatisch Metadatenfilter aus Benutzeranfragen generieren können, um Suchergebnisse zu verfeinern und zu kontextualisieren, Verwirrung zu vermeiden und die Genauigkeit der abgerufenen Informationen zu verbessern, selbst bei komplexen Abfragen.

• Zusammenfassung Am Ende dieses Notizbuchs werden Sie ein umfassendes Verständnis für die Verwendung von Milvus, Llama-Index mit Llama-Agenten und Mistral-Modellen haben, um ein robustes und effizientes Datenabfragesystem aufzubauen.

Milvus

Milvus ist eine Open-Source-Vektordatenbank, die KI-Anwendungen mit Vektoreinbettungen und Ähnlichkeitssuche unterstützt.

In diesem Notizbuch verwenden wir Milvus Lite, die abgespeckte Version von Milvus.

Mit Milvus Lite können Sie innerhalb weniger Minuten eine KI-Anwendung mit Vektorähnlichkeitssuche erstellen! Milvus Lite kann in den folgenden Umgebungen eingesetzt werden:

• Jupyter Notebook / Google Colab
• Laptops
• Edge-Geräte

bild.png

Lama-Agenten

llama-agents macht es möglich, Agenten als Microservices zu betreiben. Das ermöglicht die Skalierung von Diensten nach oben und unten.

lama-index

LlamaIndex ist ein Daten-Framework für Ihre LLM-Anwendung. Es bietet Werkzeuge wie:

• Datenkonnektoren nehmen Ihre vorhandenen Daten aus ihrer nativen Quelle und ihrem Format auf.
• Datenindizes strukturieren Ihre Daten in Zwischenrepräsentationen, die für LLMs einfach und performant zu nutzen sind.
• Engines bieten natürlichsprachlichen Zugang zu Ihren Daten.
• Agenten sind LLM-gestützte Wissensarbeiter, die durch Tools erweitert werden, von einfachen Hilfsfunktionen bis zu API-Integrationen und mehr.

bild.png

Mistral KI

Mistral AI ist ein Forschungslabor, das LLMs und Einbettungsmodelle entwickelt. Sie haben kürzlich neue Versionen ihrer Modelle, Mistral Nemo und Mistral Large, veröffentlicht, die sich als besonders gut in RAG und Funktionsaufrufen erwiesen haben. Aus diesem Grund werden wir sie in diesem Notizbuch verwenden.

Abhängigkeiten installieren

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

Besorge dir deinen API Schlüssel für Mistral

Sie können den Mistral API Schlüssel von der Mistral Cloud Console erhalten.

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

Daten herunterladen

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

Einbettungsmodell vorbereiten

Wir definieren das Einbettungsmodell, das in diesem Notizbuch verwendet werden soll. Wir verwenden mistral-embed, es ist ein von Mistral entwickeltes Einbettungsmodell, das mit Retrievals im Hinterkopf trainiert wurde, was es zu einem sehr guten Modell für unser Agentic RAG System macht. Details finden Sie auf der Seite Embedding in der Mistral Dokumentation.

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

Definieren Sie das LLM-Modell

Llama Index verwendet LLMs, um auf Prompts und Abfragen zu reagieren, und ist für das Schreiben natürlichsprachlicher Antworten verantwortlich. Wir definieren Mistral Nemo als Standardmodell. Nemo bietet ein großes Kontextfenster von bis zu 128k Token. Sein logisches Denken, sein Weltwissen und seine Kodiergenauigkeit sind in seiner Größenklasse auf dem neuesten Stand.

from llama_index.llms.ollama import Ollama

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

Milvus instanziieren und Daten laden

Milvus ist eine beliebte Open-Source-Vektordatenbank, die KI-Anwendungen mit einer hochleistungsfähigen und skalierbaren Vektorähnlichkeitssuche versorgt.

• Die Einstellung der Uri als lokale Datei, z. B../milvus.db, ist die bequemste Methode, da sie automatisch Milvus Lite verwendet, um alle Daten in dieser Datei zu speichern.
• Wenn Sie große Datenmengen haben, z. B. mehr als eine Million Vektoren, können Sie einen leistungsfähigeren Milvus-Server auf Docker oder Kubernetes einrichten. In diesem Fall verwenden Sie bitte die Server-Uri, z. B.http://localhost:19530, als Ihre Uri.
• Wenn Sie Zilliz Cloud, den vollständig verwalteten Cloud-Service für Milvus, nutzen möchten, passen Sie die uri und das Token an, die dem Public Endpoint und dem API-Schlüssel in Zilliz Cloud entsprechen.

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)

Tools definieren

Einer der wichtigsten Schritte beim Aufbau eines effektiven Agenten ist die Definition der Tools, die er zur Ausführung seiner Aufgaben verwenden kann. Diese Tools sind im Wesentlichen Funktionen oder Dienste, die der Agent aufrufen kann, um Informationen abzurufen oder Aktionen auszuführen.

Im Folgenden werden wir zwei Tools definieren, mit denen unser Agent Finanzinformationen über Lyft und Uber aus dem Jahr 2021 abfragen kann. Diese Tools werden in unseren Agenten integriert, so dass er auf natürlichsprachliche Abfragen mit präzisen und relevanten Informationen reagieren kann.

In der Grafik oben sehen Sie, was ein "Agentendienst" ist.

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

Metadaten-Filterung

Milvus unterstützt die Filterung von Metadaten, eine Technik, mit der Sie die Suchergebnisse auf der Grundlage bestimmter Attribute oder Tags, die mit Ihren Daten verbunden sind, verfeinern und eingrenzen können. Dies ist besonders nützlich in Szenarien, in denen Sie viele Daten haben und nur die relevante Teilmenge von Daten abrufen müssen, die bestimmten Kriterien entsprechen.

Anwendungsfälle für das Filtern von Metadaten

• Präzision in Suchergebnissen: Durch die Anwendung von Metadatenfiltern können Sie sicherstellen, dass die Suchergebnisse in hohem Maße relevant für die Suchanfrage des Benutzers sind. Wenn Sie z. B. eine Sammlung von Finanzdokumenten haben, können Sie diese auf der Grundlage des Firmennamens, des Jahres oder anderer relevanter Metadaten filtern.

• Effizienter: Die Filterung von Metadaten trägt dazu bei, die zu verarbeitende Datenmenge zu reduzieren und die Suchvorgänge effizienter zu gestalten. Dies ist vor allem bei großen Datenbeständen von Vorteil.

• Anpassungsfähigkeit: Verschiedene Benutzer oder Anwendungen können unterschiedliche Anforderungen haben. Mit der Metadatenfilterung können Sie die Suchergebnisse an spezifische Anforderungen anpassen, z. B. an die Suche nach Dokumenten aus einem bestimmten Jahr oder Unternehmen.

Beispiel für die Verwendung

Im folgenden Codeblock wird die Metadatenfilterung verwendet, um eine gefilterte Abfragemaschine zu erstellen, die Dokumente auf der Grundlage eines bestimmten Metadaten-Schlüssel-Wert-Paares abruft: file_name: lyft_2021.pdf

Die unten definierte QueryEngineTool ist allgemeiner als die oben definierte, in der obigen hatten wir ein Tool pro Unternehmen (Uber und Lyft), in dieser ist es allgemeiner. Wir wissen nur, dass wir Finanzdokumente über Unternehmen haben, aber das war's auch schon. Durch Hinzufügen eines Metadatenfilters können wir dann filtern, um nur Daten aus einem bestimmten Dokument zu erhalten.

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

Funktionsaufrufe

Mistral Nemo und Large unterstützen native Funktionsaufrufe. Es gibt eine nahtlose Integration mit LlamaIndex-Tools durch die predict_and_call Funktion auf dem LLM. Dies erlaubt dem Benutzer, beliebige Tools anzuhängen und den LLM entscheiden zu lassen, welche Tools aufgerufen werden sollen (wenn überhaupt).

Weitere Informationen über Agenten finden Sie auf der Llama-Index-Website.

# Set up the LLM we will use for Function Calling

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

Interaktion mit dem Agenten

Jetzt können wir die Metadatenfilterung in Aktion sehen:

1. Im ersten Fall sollte der Agent nichts zu der Anfrage des Benutzers finden können, da es sich um Uber handelt und wir nur nach Dokumenten über Lyft filtern.
2. Im zweiten Fall sollte der Agent in der Lage sein, Informationen über Lyft zu finden, da wir nur Dokumente durchsuchen, die sich auf Lyft beziehen.

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.

Beispiel für Verwirrung ohne Metadatenfilterung

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

In diesem Beispiel liefert das System fälschlicherweise Informationen über Lyft statt über Uber, was zu einer irreführenden Antwort führt. Es beginnt mit der Aussage, dass es die Informationen nicht hat, und fährt dann immer weiter fort.

Verwendung eines Agenten zur Extraktion von Metadatenfiltern

Um dieses Problem zu lösen, können wir einen Agenten einsetzen, der automatisch Metadatenfilter aus der Frage des Benutzers extrahiert und diese während des Beantwortungsprozesses anwendet. Dadurch wird sichergestellt, dass das System die richtigen und relevanten Informationen abruft.

Code-Beispiel

Das folgende Code-Beispiel zeigt, wie eine gefilterte Abfrage-Engine mit Hilfe eines Agenten erstellt wird, der Metadatenfilter aus der Frage des Benutzers extrahiert:

Erläuterung

• Prompt-Vorlage: Die Klasse PromptTemplate wird verwendet, um eine Vorlage für die Extraktion von Metadatenfiltern aus der Frage des Benutzers zu definieren. Die Vorlage weist das Sprachmodell an, Firmennamen, Jahreszahlen und andere relevante Attribute zu berücksichtigen.

• LLM: Mistral Nemo wird verwendet, um die Metadatenfilter basierend auf der Frage des Benutzers zu generieren. Das Modell wird mit der Frage und der Vorlage aufgefordert, die relevanten Filter zu extrahieren.

• Metadaten-Filter: Die Antwort des LLM wird geparst, um ein MetadataFilters Objekt zu erstellen. Wenn keine spezifischen Filter erwähnt werden, wird ein leeres MetadataFilters Objekt zurückgegeben.

• Filtered Query Engine: Die Methode index.as_query_engine(filters=metadata_filters) erstellt eine Query Engine, die die extrahierten Metadatenfilter auf den Index anwendet. Dadurch wird sichergestellt, dass nur die Dokumente abgerufen werden, die den Filterkriterien entsprechen.

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.

Orchestrierung der verschiedenen Dienste mit Mistral Large

Mistral Large ist das Flaggschiff-Modell von Mistral mit sehr guten Argumentations-, Wissens- und Kodierungsfähigkeiten. Es ist ideal für komplexe Aufgaben, die umfangreiche Fähigkeiten zum Reasoning erfordern oder hoch spezialisiert sind. Es verfügt über fortgeschrittene Funktionsaufrufe, was genau das ist, was wir brauchen, um unsere verschiedenen Agenten zu orchestrieren.

Warum brauchen wir ein intelligenteres Modell?

Die Frage, die wir im Folgenden beantworten wollen, ist besonders anspruchsvoll, weil sie die Orchestrierung mehrerer Dienste und Agenten erfordert, um eine kohärente und genaue Antwort zu geben. Dazu müssen verschiedene Tools und Agenten koordiniert werden, um Informationen aus unterschiedlichen Quellen abzurufen und zu verarbeiten, z. B. Finanzdaten von verschiedenen Unternehmen.

Was ist daran so schwierig?

• Die Komplexität: Die Frage betrifft mehrere Agenten und Dienste, von denen jeder über eigene Funktionen und Datenquellen verfügt. Diese Agenten so zu koordinieren, dass sie nahtlos zusammenarbeiten, ist eine komplexe Aufgabe.

• Datenintegration: Die Frage erfordert die Integration von Daten aus verschiedenen Quellen, was aufgrund der unterschiedlichen Datenformate, -strukturen und -metadaten eine Herausforderung darstellen kann.

• Verständnis des Kontextes: Die Fragestellung kann ein Verständnis des Kontextes und der Beziehungen zwischen verschiedenen Informationen erfordern, was eine kognitiv anspruchsvolle Aufgabe ist.

Warum sollte Mistral Large in diesem Fall helfen?

Mistral Large ist für diese Aufgabe gut geeignet, da es über fortgeschrittene Argumentations- und Funktionsaufrufe verfügt. Hier ist, wie es hilft:

• Fortgeschrittenes Reasoning: Mistral Large kann komplexe Schlussfolgerungen ziehen und ist daher ideal für die Orchestrierung von mehreren Agenten und Diensten. Er kann die Beziehungen zwischen verschiedenen Informationen verstehen und fundierte Entscheidungen treffen.

• Funktionsaufruf-Fähigkeiten: Mistral Large verfügt über fortschrittliche Funktionsaufrufe, die für die Koordinierung der Aktionen verschiedener Agenten unerlässlich sind. Dies ermöglicht eine nahtlose Integration und Orchestrierung von verschiedenen Diensten.

• Spezialisiertes Wissen: Mistral Large wurde für hochspezialisierte Aufgaben entwickelt und eignet sich daher gut für die Bearbeitung komplexer Abfragen, die tiefes Domänenwissen erfordern.

Aus all diesen Gründen habe ich entschieden, dass Mistral Large anstelle von Mistral Nemo hier besser geeignet ist.

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

Schlussfolgerung

In diesem Notizbuch haben Sie gesehen, wie Sie Llama-Agenten verwenden können, um verschiedene Aktionen auszuführen, indem Sie entsprechende Tools aufrufen. Durch die Verwendung von Mistral Large in Kombination mit Mistral Nemo haben wir gezeigt, wie man intelligente, ressourceneffiziente Systeme effektiv orchestrieren kann, indem man die Stärken verschiedener LLMs nutzt. Wir haben gesehen, dass der Agent die Sammlung auswählen kann, die die vom Benutzer angeforderten Daten enthält.