Geração Aumentada por Recuperação com Citações
Quando você recebe respostas dos seus aplicativos de modelos de linguagem grandes (LLM), quer saber de onde essa resposta veio? Esse é o poder das citações ou atribuições. Neste tutorial, veremos por que é importante incluir citações, como você pode obter citações em alto nível e, em seguida, mergulharemos em um exemplo de código!
Por que citar suas fontes de Retrieval Augmented Generation (RAG)?
Retrieval Augmented Generation é uma técnica usada com aplicativos de LLM para complementar seu conhecimento. Uma das principais fraquezas dos LLMs em geral é a falta de conhecimento atualizado ou específico de domínio. Existem duas soluções principais para isso: ajuste fino e geração aumentada por recuperação.
Aqui na Zilliz e em outras empresas como a OpenAI, propomos o RAG como a opção superior ao ajuste fino para recuperação baseada em fatos. O ajuste fino é mais caro e exige muito mais dados; no entanto, é uma boa opção para transferência de estilo. O RAG usa um banco de dados vetorial como o Milvus para inserir seu conhecimento no seu aplicativo.
Em vez de perguntar ao LLM sobre seu produto ou documentação, você pode usar um banco de dados vetorial como seu repositório da verdade. Isso garante que seu aplicativo retorne o conhecimento correto e não alucine na tentativa de compensar a falta de dados. À medida que você começa a adicionar mais documentos e casos de uso, torna-se cada vez mais importante saber onde essa informação está.
É aqui que entram as citações e atribuições. Quando você recebe uma resposta do seu aplicativo de LLM, quer saber como ele obteve aquela informação. Receber respostas com citações ou atribuições mostra qual trecho de texto/onde no texto sua resposta se originou. À medida que temos cada vez mais dados, isso se torna crítico para determinar respostas confiáveis.
Como você pode citar suas fontes de RAG?
Os LLMs impulsionaram a popularidade de ferramentas adjacentes, como bancos de dados vetoriais como o Milvus. Isso também deu origem a frameworks como LangChain e LlamaIndex. Como parte desse aumento de popularidade, a geração aumentada por recuperação tornou-se um aplicativo essencial, especialmente quando se trata de recuperação de informações nos seus dados internos.
Além de recuperar dados, muitas pessoas perceberam que adicionar citações aos seus dados recuperados torna seu aplicativo mais robusto, mais explicável e fornece mais contexto. Então, como você faz isso? Há muitas maneiras de fazer isso. Você pode armazenar os fragmentos de texto dentro do seu banco de dados vetorial se ele oferecer suporte a metadados como o Milvus, ou pode usar um framework como o LlamaIndex. Este tutorial abordará como fazer RAG com citações usando LlamaIndex e Milvus.
Exemplo de Retrieval Augmented Generation com fontes
Vamos mergulhar no código. Para fazer este tutorial, você precisa executar pip install milvus llama-index python-dotenv. As bibliotecas milvus e llama-index são para a funcionalidade principal, enquanto python-dotenv é para carregar suas variáveis de ambiente, como sua chave de API da OpenAI. Neste exemplo, extraímos alguns dados sobre diferentes cidades da Wikipedia e fazemos uma consulta com citações sobre isso.
Importamos algumas bibliotecas necessárias e carregamos nossa chave de API da OpenAI. Precisamos de sete submódulos do LlamaIndex. Sem ordem específica: OpenAI para acessar um LLM, CitationQueryEngine para criar o mecanismo de consulta com citações e MilvusVectorStore para usar o Milvus como um armazenamento vetorial. Além disso, também importamos VectorStoreIndex para usar o Milvus, SimpleDirectoryReader para ler dados locais, e StorageContext e ServiceContext para dar ao índice vetorial acesso ao Milvus. Por fim, usamos load_dotenv para carregar nossa chave de API da OpenAI.
from llama_index.llms import OpenAI
from llama_index.query_engine import CitationQueryEngine
from llama_index import (
VectorStoreIndex,
SimpleDirectoryReader,
StorageContext,
ServiceContext,
)
from llama_index.vector_stores import MilvusVectorStore
from milvus import default_server
from dotenv import load_dotenv
import os
load_dotenv()
open_api_key = os.getenv("OPENAI_API_KEY")
Fazendo scraping de alguns dados de teste
Vamos começar nosso projeto primeiro tendo alguns dados com os quais trabalhar. Para este exemplo, fazemos scraping de alguns dados da Wikipedia. Na verdade, estamos fazendo scraping dos mesmos dados que usamos para criar um mecanismo de consulta multi-documento. O código abaixo aciona a API da Wikipedia para as páginas mencionadas na lista wiki_titles. Ele salva o resultado localmente em um arquivo de texto.
wiki_titles = ["Toronto", "Seattle", "San Francisco", "Chicago", "Boston", "Washington, D.C.", "Cambridge, Massachusetts", "Houston"]
from pathlib import Path
import requests
for title in wiki_titles:
response = requests.get(
'https://en.wikipedia.org/w/api.php',
params={
'action': 'query',
'format': 'json',
'titles': title,
'prop': 'extracts',
'explaintext': True,
}
).json()
page = next(iter(response['query']['pages'].values()))
wiki_text = page['extract']
data_path = Path('data')
if not data_path.exists():
Path.mkdir(data_path)
with open(data_path / f"{title}.txt", 'w') as fp:
fp.write(wiki_text)
Configurando seu armazenamento vetorial no LlamaIndex
Agora que temos todos os nossos dados, podemos configurar a lógica do app para nosso app de RAG com citações. Para começar, a primeira coisa que precisamos fazer é iniciar um banco de dados vetorial. Neste exemplo, usamos o Milvus Lite para executá-lo diretamente em nosso notebook. Em seguida, usamos o módulo MilvusVectorStore do LlamaIndex para nos conectar ao Milvus como nosso armazenamento vetorial.
default_server.start()
vector_store = MilvusVectorStore(
collection_name="citations",
host="127.0.0.1",
port=default_server.listen_port
)
Em seguida, vamos criar os contextos para nosso índice. O contexto de serviço informa ao índice e ao recuperador quais serviços usar. Neste caso, ele está passando GPT 3.5 Turbo como o LLM desejado. Também criamos um contexto de armazenamento para que o índice saiba onde armazenar e consultar dados. Neste caso, passamos o objeto de armazenamento vetorial do Milvus que criamos acima.
service_context = ServiceContext.from_defaults(
llm=OpenAI(model="gpt-3.5-turbo", temperature=0)
)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
Com tudo isso configurado, podemos carregar os dados que coletamos anteriormente e criar um índice de armazenamento vetorial a partir desses documentos.
documents = SimpleDirectoryReader("./data/").load_data()
index = VectorStoreIndex.from_documents(documents, service_context=service_context, storage_context=storage_context)
Consultando com citações
Agora podemos criar um Citation Query Engine. Fornecemos a ele o índice vetorial que criamos anteriormente e parâmetros sobre quantos resultados retornar, e o tamanho do chunk da citação. Isso é tudo que há para configurar a citação, e o próximo passo é consultar o mecanismo.
query_engine = CitationQueryEngine.from_args(
index,
similarity_top_k=3,
# here we can control how granular citation sources are, the default is 512
citation_chunk_size=512,
)
response = query_engine.query("Does Seattle or Houston have a bigger airport?")
print(response)
for source in response.source_nodes:
print(source.node.get_text())
Quando consultamos, a resposta se parece com algo assim.
Consultando com citações
Resumo
Neste tutorial, aprendemos como fazer geração aumentada por recuperação com citações (atribuições). A geração aumentada por recuperação é um tipo de aplicação de LLM que muitas empresas querem construir. Além de recuperar e formatar suas informações em um formato digerível, também queremos saber de onde vêm as informações.
Podemos construir esse tipo de aplicação RAG usando o LlamaIndex como nosso roteador de dados e o Milvus como nosso armazenamento vetorial. Começamos extraindo alguns dados da Wikipedia para mostrar como isso funciona. Em seguida, iniciamos uma instância do Milvus e criamos uma instância de armazenamento vetorial no LlamaIndex. A partir daí, colocamos nossos dados no Milvus e usamos o LlamaIndex para acompanhar as atribuições e citações usando um mecanismo de consulta com citações. Podemos então consultar esse mecanismo de consulta e obter respostas, incluindo de onde, no texto, e de qual texto estamos extraindo nossa resposta.
Continue lendo
How Zilliz Ended Up at the Center of NVIDIA’s Unstructured Data Story at GTC 2026
If unstructured data is the context of AI, then the ceiling of AI applications will be set not just by models, but by how mature the infrastructure for unstructured data becomes.
How to Improve Retrieval Quality for Japanese Text with Sudachi, Milvus/Zilliz, and AWS Bedrock
Learn how Sudachi normalization and Milvus/Zilliz hybrid search improve Japanese RAG accuracy with BM25 + vector fusion, AWS Bedrock embeddings, and practical code examples.
Introducing DeepSearcher: A Local Open Source Deep Research
In contrast to OpenAI’s Deep Research, this example ran locally, using only open-source models and tools like Milvus and LangChain.