Generación aumentada por recuperación con citas
Cuando recibes respuestas de tus aplicaciones de modelos de lenguaje grandes (LLM), ¿quieres saber de dónde provino esa respuesta? Ese es el poder de las citas o atribuciones. En este tutorial, veremos por qué es importante incluir citas, cómo puedes obtener citas desde un nivel alto y luego nos sumergiremos en un ejemplo de código.
¿Por qué citar tus fuentes de Retrieval Augmented Generation (RAG)?
Retrieval Augmented Generation es una técnica utilizada con aplicaciones de LLM para complementar su conocimiento. Una de las principales debilidades de los LLM en general es su falta de conocimiento actualizado o específico del dominio. Hay dos soluciones principales para esto: ajuste fino y generación aumentada por recuperación.
Aquí en Zilliz y en otras empresas como OpenAI, proponemos RAG como la opción superior al ajuste fino para la recuperación basada en hechos. El ajuste fino es más caro y requiere muchos más datos; sin embargo, es una buena opción para la transferencia de estilo. RAG utiliza una base de datos vectorial como Milvus para inyectar tu conocimiento en tu aplicación.
En lugar de preguntarle al LLM sobre tu producto o documentación, puedes usar una base de datos vectorial como tu repositorio de verdad. Esto garantiza que tu aplicación devuelva el conocimiento correcto y no alucine en un intento de compensar la falta de datos. A medida que empiezas a agregar más documentos y casos de uso, se vuelve cada vez más importante saber dónde se encuentra esa información.
Aquí es donde entran en juego las citas y atribuciones. Cuando recibes una respuesta de tu aplicación LLM, quieres saber cómo obtuvo esa información. Recibir respuestas con citas o atribuciones te muestra qué fragmento de texto/en qué parte del texto provino tu respuesta. A medida que tenemos cada vez más datos, esto se vuelve fundamental para determinar respuestas confiables.
¿Cómo puedes citar tus fuentes de RAG?
Los LLM han impulsado la popularidad de herramientas adyacentes, como bases de datos vectoriales como Milvus. También ha dado lugar a frameworks como LangChain y LlamaIndex. Como parte de este aumento de popularidad, la generación aumentada por recuperación se ha convertido en una aplicación esencial, especialmente cuando se trata de recuperación de información en tus datos internos.
Además de recuperar datos, muchas personas se han dado cuenta de que añadir citas a tus datos recuperados hace que tu aplicación sea más robusta, más explicable y proporciona más contexto. Entonces, ¿cómo lo haces? Hay muchas formas de hacerlo. Puedes almacenar los fragmentos de texto dentro de tu base de datos vectorial si admite metadatos como Milvus, o puedes usar un framework como LlamaIndex. Este tutorial cubrirá cómo hacer RAG con citas usando LlamaIndex y Milvus.
Ejemplo de Retrieval Augmented Generation con fuentes
Profundicemos en el código. Para hacer este tutorial, necesitas pip install milvus llama-index python-dotenv. Las bibliotecas milvus y llama-index son para la funcionalidad principal, mientras que python-dotenv es para cargar tus variables de entorno, como tu clave de API de OpenAI. En este ejemplo, extraemos algunos datos sobre diferentes ciudades de Wikipedia y hacemos una consulta con citas sobre eso.
Importamos algunas bibliotecas necesarias y cargamos nuestra clave de API de OpenAI. Necesitamos siete submódulos de LlamaIndex. Sin ningún orden en particular: OpenAI para acceder a un LLM, CitationQueryEngine para crear el motor de consultas con citas y MilvusVectorStore para usar Milvus como almacén vectorial. Además, también importamos VectorStoreIndex para usar Milvus, SimpleDirectoryReader para leer datos locales, y StorageContext y ServiceContext para dar al índice vectorial acceso a Milvus. Finalmente, usamos load_dotenv para cargar nuestra clave de API de 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")
Extracción de algunos datos de prueba
Comencemos nuestro proyecto teniendo primero algunos datos con los que trabajar. Para este ejemplo, extraemos algunos datos de Wikipedia. En realidad, estamos extrayendo los mismos datos que usamos para crear un motor de consultas multidocumento. El código de abajo consulta la API de Wikipedia para las páginas mencionadas en la lista wiki_titles. Guarda el resultado localmente en un archivo 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)
Configuración de tu almacén vectorial en LlamaIndex
Ahora que tenemos todos nuestros datos, podemos configurar la lógica de la aplicación para nuestra app de RAG con citas. Para empezar, lo primero que debemos hacer es poner en marcha una base de datos vectorial. En este ejemplo, usamos Milvus Lite para ejecutarla directamente en nuestro notebook. Luego usamos el módulo MilvusVectorStore de LlamaIndex para conectarnos a Milvus como nuestro almacén vectorial.
default_server.start()
vector_store = MilvusVectorStore(
collection_name="citations",
host="127.0.0.1",
port=default_server.listen_port
)
A continuación, creemos los contextos para nuestro índice. El contexto de servicio indica al índice y al recuperador qué servicios usar. En este caso, pasa GPT 3.5 Turbo como el LLM deseado. También creamos un contexto de almacenamiento para que el índice sepa dónde almacenar y consultar los datos. En este caso, pasamos el objeto de almacén vectorial de Milvus que creamos arriba.
service_context = ServiceContext.from_defaults(
llm=OpenAI(model="gpt-3.5-turbo", temperature=0)
)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
Con todo esto configurado, podemos cargar los datos que extrajimos antes y crear un índice de almacén vectorial a partir de esos documentos.
documents = SimpleDirectoryReader("./data/").load_data()
index = VectorStoreIndex.from_documents(documents, service_context=service_context, storage_context=storage_context)
Consultas con citas
Ahora podemos crear un motor de consultas con citas. Le damos el índice vectorial que construimos antes y parámetros sobre cuántos resultados devolver, y el tamaño del fragmento de la cita. Eso es todo lo que se necesita para configurar la cita, y el siguiente paso es consultar el motor.
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())
Cuando hacemos una consulta, la respuesta se ve más o menos así.
Consultas con citas
Resumen
En este tutorial, aprendimos cómo hacer generación aumentada por recuperación con citas (atribuciones). La generación aumentada por recuperación es un tipo de aplicación de LLM que muchas empresas quieren crear. Además de recuperar y formatear tu información en un formato digerible, también queremos saber de dónde proviene la información.
Podemos crear este tipo de aplicación RAG usando LlamaIndex como nuestro enrutador de datos y Milvus como nuestro almacén de vectores. Comenzamos extrayendo algunos datos de Wikipedia para mostrar cómo funciona esto. Luego, iniciamos una instancia de Milvus y creamos una instancia de almacén de vectores en LlamaIndex. A partir de ahí, colocamos nuestros datos en Milvus y usamos LlamaIndex para hacer un seguimiento de las atribuciones y citas usando un motor de consultas de citas. Luego podemos consultar ese motor de consultas y obtener respuestas, incluyendo de dónde en el texto y de qué texto estamos extrayendo nuestra respuesta.
Sigue leyendo
Introducing Loon: A New Storage Engine for Vector Data That Never Stops Changing
Loon is a new storage engine for Milvus 3.0 and Zilliz Vector Lakebase, built to manage evolving vector datasets with ColumnGroups, row ID alignment, and Manifests.
Zilliz Named "Highest Performer" and "Easiest to Use" in G2's Summer 2025 Grid® Report for Vector Databases
Zilliz shines in G2's Summer 2025 Grid® Report as both "Highest Performer" and "Easiest to Use," solving the performance-usability dilemma.
Milvus/Zilliz + Surveillance: How Vector Databases Transform Multi-Camera Tracking
See how Milvus vector database enhances multi-camera tracking with similarity-based matching for better surveillance in retail, warehouses and transport hubs.