Criando um agente de IA para RAG com Milvus e LlamaIndex
Em 2023, houve uma enorme explosão na popularidade dos grandes modelos de linguagem (LLMs) e, como resultado, das aplicações de LLM. Os dois tipos mais populares de aplicações de LLM que ganharam destaque são a geração aumentada por recuperação (RAG) e os agentes de IA. RAG consiste em usar um banco de dados vetorial como o Milvus para inserir dados contextuais. Agentes de IA consistem em usar LLMs para utilizar outras ferramentas. Você pode encontrar o notebook no GitHub.
A OpenAI dispensa apresentações. Para acessar os serviços da OpenAI, é necessário adicionar a chave de API da OpenAI, especialmente para funcionalidades como embeddings e o uso do ChatGPT.
Neste artigo, vamos combinar os dois. Abordamos:
A Stack Tecnológica: Milvus e LlamaIndex
Milvus Lite
Milvus no Docker Compose
LlamaIndex
Construindo um Agente de IA para RAG
Inicializando o Milvus
Carregando os Dados no Milvus via LlamaIndex
Criando as Ferramentas de Mecanismo de Consulta para o Agente de IA
Criando o Agente de IA para RAG
Resumo da Construção de um Agente de IA para RAG com Milvus e LlamaIndex
Introdução ao Milvus e ao LlamaIndex para RAG
Milvus e LlamaIndex são duas ferramentas poderosas que podem ser usadas em conjunto para criar um sistema de Geração Aumentada por Recuperação (RAG). Milvus é um banco de dados vetorial que permite o armazenamento e a consulta eficientes de grandes volumes de dados, enquanto LlamaIndex é uma biblioteca que fornece uma forma simples e flexível de interagir com o Milvus e outros bancos de dados vetoriais. Ao combinar essas duas ferramentas, os desenvolvedores podem criar sistemas RAG capazes de recuperar e gerar texto de forma eficiente com base em um determinado prompt.
O Milvus se destaca no tratamento de dados vetoriais em grande escala, tornando-o ideal para aplicações que exigem busca por similaridade de alto desempenho. Por outro lado, o LlamaIndex simplifica o processo de indexação e consulta desses dados, fornecendo uma interface integrada para desenvolvedores. Juntos, eles formam uma base robusta para sistemas RAG, permitindo a recuperação de informações relevantes e a geração de respostas contextualmente precisas.
A Stack Tecnológica: Milvus Vector Store e LlamaIndex
Para este Agente de IA que realiza RAG, na verdade usamos três tecnologias: Milvus, LlamaIndex e OpenAI. A OpenAI dispensa apresentações. Você também pode usar OctoAI ou um LLM da HuggingFace como substituto direto. Podemos atualizar isto com uma versão usando um deles posteriormente.
Há muitas maneiras de usar o Milvus. Milvus Lite, que podemos inicializar diretamente em nosso notebook Jupyter, e Milvus por meio do Docker. O Milvus lite pode ser instalado pelo PyPi usando pip install milvus. O milvus vector store permite carregar dados e habilitar capacidades de busca com base em vetores de consulta. Então, ele pode ser inicializado, usado e encerrado diretamente no seu notebook.
Milvus é um sistema distribuído, então, naturalmente, faz sentido inicializar o Milvus com Docker Compose. O arquivo docker compose está disponível na página e no GitHub do Milvus. Ao inicializar o Milvus com Docker Compose, você verá três contêineres e se conectará ao Milvus pela porta 19530 por padrão.
LlamaIndex
LlamaIndex é um dos frameworks mais populares para criar apps de LLM. É um dos três projetos populares - LlamaIndex, LangChain e Haystack. O foco principal do LlamaIndex é fornecer um framework especializado para tarefas de recuperação. Além disso, ele fornece ferramentas para criar Agentes de IA.
Há muitas maneiras de criar RAG e Agentes de IA. Este exemplo se baseia no meu tutorial original sobre um Agente de IA RAG. A principal diferença entre esses dois exemplos é que este usa Milvus como um armazenamento vetorial persistente com LlamaIndex. As importações do LlamaIndex permanecem as mesmas - as três importações que obtemos da parte central do LlamaIndex são o leitor de diretório, o índice de armazenamento vetorial e o contexto de armazenamento.
Também pegamos a ferramenta de engenheiro de consultas e o objeto de metadados da ferramenta para criar e descrever nossa ferramenta para RAG. Em comparação com a última versão, a importação adicional que fazemos aqui é para obter o objeto MilvusVectorStore para o LlamaIndex. Para obter tudo isso, você precisa executar pip install -U llama-index llama-index-vector-stores-milvus pymilvus llama-index-llms-openai llama-index-readers-file.
from llama_index.core import (
SimpleDirectoryReader,
VectorStoreIndex,
StorageContext
)
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.vector_stores.milvus import MilvusVectorStore
Uma etapa crítica ao fazer RAG com um backend de banco de dados vetorial é iniciar nosso banco de dados vetorial. Milvus é o único banco de dados vetorial distribuído do mercado, e ele é iniciado de duas maneiras. Primeiro, podemos importar diretamente o default_server e executá-lo com start(). Segundo, podemos iniciá-lo via Docker Compose. O código para ambos é mostrado abaixo.
from milvus import default_server
default_server.start()
Ou execute docker compose up -d no terminal no mesmo diretório em que seu arquivo docker-compose.yml está.
A única diferença entre nossas instâncias do Milvus que armazenam os dados é o nome da coleção. É importante definir o nível de consistência para garantir a integridade dos dados durante as operações, sendo a configuração padrão 'Strong'.
Carregando os Dados do Documento no Milvus via LlamaIndex
O primeiro passo para criar um app RAG é carregar seus dados no seu banco de dados vetorial. Para este tutorial, fazemos isso via LlamaIndex. Usamos o leitor de diretório simples deles para ler os arquivos de entrada. Neste caso, estamos analisando os documentos financeiros da Lyft e da Uber. O processo de criação de coleção envolve configurar um banco de dados onde os dados são estruturados e indexados, garantindo gerenciamento e recuperação de dados eficazes.
# load data
lyft_docs = SimpleDirectoryReader(
input_files=["./data/10k/lyft_2021.pdf"]
).load_data()
uber_docs = SimpleDirectoryReader(
input_files=["./data/10k/uber_2021.pdf"]
).load_data()
Depois que os dados são carregados, precisamos criar um objeto MilvusVectorStore no LlamaIndex para armazená-los. Usamos OpenAI tanto para o modelo de embeddings quanto para o LLM neste exemplo, então passamos uma dimensão de 1536. A única diferença entre nossas instâncias do Milvus que armazenam os dados é o nome da coleção. Também é possível sobrescrever uma coleção existente com o mesmo nome, se necessário.
Se você usar Milvus Lite em vez do Milvus por meio do Docker Compose, também deverá passar o host e a porta para garantir que você se conecte à porta correta. Devemos obter a porta do servidor padrão por meio da opção listen_port.
# build index
vector_store_lyft = MilvusVectorStore(dim=1536, collection_name="lyft", overwrite=True)
vector_store_uber = MilvusVectorStore(dim=1536, collection_name="uber", overwrite=True)
# for milvus lite users
if milvuslite:
vector_store_lyft = MilvusVectorStore(host="localhost", port=default_server.listen_port, dim=1536, collection_name="lyft", overwrite=True)
vector_store_uber = MilvusVectorStore(host="localhost", port=default_server.listen_port, dim=1536, collection_name="uber", overwrite=True)
Precisamos ser capazes de passar os dados adiante, não apenas carregá-los. O LlamaIndex lida com essa abstração fornecendo um objeto StorageContext. Passamos o armazenamento vetorial para o contexto de armazenamento tanto para Lyft quanto para Uber para poder passar esses dados adiante. Em seguida, criamos índices nesses armazenamentos vetoriais. As duas últimas linhas neste bloco persistem esses armazenamentos vetoriais no seu disco local para que você possa recuperá-los do armazenamento na próxima vez.
storage_context_lyft = StorageContext.from_defaults(vector_store=vector_store_lyft)
storage_context_uber = StorageContext.from_defaults(vector_store=vector_store_uber)
lyft_index = VectorStoreIndex.from_documents(lyft_docs, storage_context=storage_context_lyft)
uber_index = VectorStoreIndex.from_documents(uber_docs, storage_context=storage_context_uber)
# persist index
lyft_index.storage_context.persist(persist_dir="./storage/lyft")
uber_index.storage_context.persist(persist_dir="./storage/uber")
Criando as ferramentas de mecanismo de consulta para o agente de IA
Para que um agente de IA faça RAG, ele precisa ser capaz de usar ferramentas para realizar consultas em bancos de dados vetoriais. Neste próximo bloco, transformamos os índices vetoriais que criamos em mecanismos de consulta que recuperam os 3 resultados mais semelhantes.
lyft_engine = lyft_index.as_query_engine(similarity_top_k=3)
uber_engine = uber_index.as_query_engine(similarity_top_k=3)
Em seguida, transformamos os mecanismos de consulta em ferramentas. O agente ReAct para LlamaIndex (importado na próxima seção) recebe uma lista de ferramentas como parte de sua entrada. Então, nesta seção, criamos essa lista de ferramentas. Só precisamos criar duas ferramentas, ambas com estruturas quase idênticas. A Ferramenta de Mecanismo de Consulta requer um mecanismo de consulta e metadados. Os metadados são usados para nomear a ferramenta e informar ao LLM o que ela faz e como usá-la.
query_engine_tools = [
QueryEngineTool(
query_engine=lyft_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."
),
),
),
QueryEngineTool(
query_engine=uber_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."
),
),
),
]
Tudo está preparado para a última peça: juntar as partes do agente. Aqui, importamos a ferramenta ReAct Agent e OpenAI do LlamaIndex. Definimos o LLM como GPT-3.5, embora você possa usar qualquer LLM que quiser. Para o agente, passamos nossa lista de ferramentas de antes, o LLM e, neste exemplo específico, “verbose” para ver seus “pensamentos”.
from llama_index.core.agent import ReActAgent
from llama_index.llms.openai import OpenAI
llm = OpenAI(model="gpt-3.5-turbo-0613")
agent = ReActAgent.from_tools(
query_engine_tools,
llm=llm,
verbose=True
)
response = agent.chat("What was Lyft's revenue growth in 2021?")
print(str(response))
Quando perguntado qual foi o crescimento da receita da Lyft em 2021, esperamos uma resposta como a abaixo.
Consultando e recuperando dados com Milvus e LlamaIndex
Para consultar e recuperar dados com Milvus e LlamaIndex, você precisa criar uma coleção Milvus e indexá-la usando LlamaIndex. Uma coleção Milvus é um contêiner que armazena um conjunto de vetores, e um índice é uma estrutura de dados que permite a consulta eficiente dos vetores. Depois de criar uma coleção e indexá-la, você pode usar o LlamaIndex para consultar a coleção e recuperar os vetores relevantes.
Para consultar uma coleção do Milvus usando o LlamaIndex, você precisa fornecer um vetor de consulta e uma métrica de similaridade. O vetor de consulta representa o prompt ou a consulta para a qual você deseja recuperar dados, e a métrica de similaridade mede o quão semelhantes dois vetores são. O LlamaIndex usa a métrica de similaridade para classificar os vetores na coleção e retornar os vetores mais bem classificados.
Por exemplo, se você deseja recuperar documentos que sejam semelhantes a um determinado documento, pode criar um vetor de consulta que representa o documento e usar o LlamaIndex para consultar a coleção. O LlamaIndex retornará uma lista de documentos que são semelhantes ao documento de consulta, junto com suas pontuações de similaridade. Esse processo garante que os documentos mais relevantes sejam recuperados, fornecendo uma base sólida para análise adicional ou geração de texto.
Construindo e Integrando o Agente de IA
Para construir e integrar um agente de IA com o Milvus e o LlamaIndex, você precisa criar uma base de conhecimento que armazene os dados que o agente usará para gerar texto. A base de conhecimento pode ser uma coleção do Milvus que armazena um conjunto de vetores, cada um representando um trecho de texto.
Para integrar o agente de IA com o Milvus e o LlamaIndex, você precisa usar o LlamaIndex para consultar a base de conhecimento e recuperar os vetores relevantes. O agente de IA pode então usar esses vetores para gerar texto com base em um determinado prompt.
Por exemplo, se você deseja construir um agente de IA que possa responder a perguntas sobre um tópico específico, pode criar uma base de conhecimento que armazene um conjunto de vetores representando documentos relacionados ao tópico. Quando o agente recebe uma pergunta, ele pode usar o LlamaIndex para consultar a base de conhecimento e recuperar os vetores relevantes. O agente pode então usar esses vetores para gerar uma resposta à pergunta.
No geral, Milvus e LlamaIndex fornecem uma combinação poderosa de ferramentas para construir sistemas RAG e agentes de IA. Ao usar essas ferramentas em conjunto, os desenvolvedores podem criar sistemas que conseguem recuperar e gerar texto com eficiência com base em um determinado prompt, tornando-os inestimáveis para aplicações em vários domínios, desde suporte ao cliente até geração de conteúdo.
Resumo da Construção de um Agente de IA para Geração Aumentada por Recuperação com Milvus e LlamaIndex
Neste artigo, construímos um Agente de IA para RAG usando Milvus, LlamaIndex e GPT 3.5. RAG é uma arquitetura de aplicativo baseada em LLM que usa bancos de dados vetoriais para inserir seus dados em um LLM como contexto . Um Agente de IA é uma aplicação baseada em LLM que pode usar outras ferramentas. Para fazer RAG com um Agente de IA, fornecemos a ele as ferramentas necessárias para fazer consultas em um banco de dados vetorial.
Neste tutorial, mostramos como construir essa arquitetura usando dados de amostra da Lyft e da Uber. Primeiro, inserimos os dados no Milvus para que pudéssemos fazer RAG. Em seguida, transformamos nossas coleções do Milvus em mecanismos de consulta e os mecanismos de consulta em ferramentas utilizáveis. Por fim, entregamos essas ferramentas a um Agente de IA e as usamos para executar RAG em nossos documentos.
Continue lendo
Build Multimodal Search for 3D Assets with Tripo and Zilliz Cloud
Generate 3D assets with Tripo, then search them by text, image, and metadata with multimodal embeddings and Zilliz Cloud.
Introducing Business Critical Plan: Enterprise-Grade Security and Compliance for Mission-Critical AI Applications
Discover Zilliz Cloud’s Business Critical Plan—offering advanced security, compliance, and uptime for mission-critical AI and vector database workloads.
AI Agents Are Quietly Transforming E-Commerce — Here’s How
Discover how AI agents transform e-commerce with autonomous decision-making, enhanced product discovery, and vector search capabilities for today's retailers.