GraphRAG explicado: mejora de RAG con grafos de conocimiento
Introducción a RAG y sus desafíos
Retrieval Augmented Generation (RAG) es una técnica que conecta fuentes de datos externas para mejorar la salida de los large language models (LLMs). Esta técnica es perfecta para que los LLMs accedan a datos privados o específicos de un dominio y aborden problemas de hallucination. Por lo tanto, RAG se ha utilizado ampliamente para impulsar muchas aplicaciones de GenAI, como chatbots de IA y sistemas de recomendación.
Un RAG básico suele integrar una base de datos vectorial y un LLM, donde la base de datos vectorial almacena y recupera información contextual para las consultas de los usuarios, y el LLM genera respuestas basadas en el contexto recuperado. Si bien este enfoque funciona bien en muchos casos, tiene dificultades con tareas complejas como el razonamiento de múltiples saltos o responder preguntas que requieren conectar piezas de información dispares.
Por ejemplo, considera esta pregunta: “¿Qué nombre se le dio al hijo del hombre que derrotó al usurpador Allectus?”
Un RAG básico generalmente seguiría estos pasos para responder esta pregunta:
Identificar al hombre: Determinar quién derrotó a Allectus.
Investigar al hijo del hombre: Buscar información sobre la familia de esta persona, específicamente su hijo.
Encontrar el nombre: Identificar el nombre del hijo.
El desafío suele surgir en el primer paso porque un RAG básico recupera texto basándose en la similitud semántica, no respondiendo directamente a consultas complejas donde detalles específicos pueden no estar mencionados explícitamente en el conjunto de datos. Esta limitación dificulta encontrar la información exacta necesaria, lo que a menudo requiere soluciones costosas y poco prácticas como crear manualmente pares de preguntas y respuestas para consultas frecuentes.
Para abordar estos desafíos, Microsoft Research presentó GraphRAG, un método completamente nuevo que aumenta la recuperación y generación de RAG con grafos de conocimiento. En las siguientes secciones, explicaremos cómo funciona GraphRAG internamente y cómo ejecutarlo con la base de datos vectorial Milvus .
¿Qué es GraphRAG y cómo funciona?
A diferencia de un RAG básico que usa una base de datos vectorial para recuperar texto semánticamente similar, GraphRAG mejora RAG incorporando grafos de conocimiento (KGs). Los grafos de conocimiento son estructuras de datos que almacenan y vinculan datos relacionados o no relacionados basándose en sus relaciones.
Un pipeline de GraphRAG suele constar de dos procesos fundamentales: indexación y consulta.
El pipeline de GraphRAG
El pipeline de GraphRAG (Fuente de la imagen: Artículo de GraphRAG)
Indexación
El proceso de indexación incluye cuatro pasos clave:
Segmentación de unidades de texto: Todo el corpus de entrada se divide en múltiples unidades de texto (fragmentos de texto). Estos fragmentos son las unidades analizables más pequeñas y pueden ser párrafos, oraciones u otras unidades lógicas. Al segmentar documentos largos en fragmentos más pequeños, podemos extraer y preservar información más detallada sobre estos datos de entrada.
Extracción de entidades, relaciones y afirmaciones: GraphRAG utiliza LLMs para identificar y extraer todas las entidades (nombres de personas, lugares, organizaciones, etc.), las relaciones entre ellas y las afirmaciones clave expresadas en el texto de cada unidad de texto. Usaremos esta información extraída para construir un grafo de conocimiento inicial.
Agrupamiento jerárquico: GraphRAG utiliza la técnica Leiden para realizar agrupamiento jerárquico en los grafos de conocimiento iniciales. Leiden es un algoritmo de detección de comunidades que puede descubrir eficazmente estructuras comunitarias dentro del grafo. Las entidades de cada clúster se asignan a diferentes comunidades para un análisis más profundo.
Nota: Una comunidad es un grupo de nodos dentro del grafo que están densamente conectados entre sí, pero escasamente conectados a otros grupos densos de la red.
- Generación de resúmenes de comunidades: GraphRAG genera resúmenes para cada comunidad y sus miembros utilizando un enfoque ascendente. Estos resúmenes incluyen las principales entidades dentro de la comunidad, sus relaciones y afirmaciones clave. Este paso ofrece una visión general de todo el conjunto de datos y proporciona información contextual útil para consultas posteriores.
Figura 1- Un grafo de conocimiento generado por un LLM construido usando GPT-4 Turbo.
Figura 1: Un grafo de conocimiento generado por un LLM construido usando GPT-4 Turbo.
(Fuente de la imagen: Microsoft Research)
Consultas
GraphRAG tiene dos flujos de trabajo de consulta diferentes adaptados a distintas consultas.
Búsqueda global para razonar sobre preguntas holísticas relacionadas con todo el corpus de datos aprovechando los resúmenes de comunidades.
Búsqueda local para razonar sobre entidades específicas expandiéndose hacia sus vecinos y conceptos asociados.
Este flujo de trabajo de búsqueda global incluye las siguientes fases.
Figura 2- Flujo de datos de búsqueda global
Figura 2: Flujo de datos de búsqueda global (Fuente de la imagen: Microsoft Research)
Consulta del usuario e historial de conversación: El sistema toma la consulta del usuario y el historial de conversación como entrada inicial.
Lotes de informes de comunidades: El sistema utiliza informes de comunidades de nodos generados por el LLM desde un nivel especificado de la jerarquía de comunidades como datos de contexto. Estos informes de comunidades se barajan y se dividen en múltiples lotes (Lote de informes de comunidades barajado 1, Lote 2... Lote N).
RIR (Respuestas intermedias calificadas): Cada lote de informes de comunidades se divide además en fragmentos de texto de tamaño predefinido. Cada fragmento de texto se utiliza para generar una respuesta intermedia. La respuesta contiene una lista de piezas de información llamadas puntos. Cada punto tiene una puntuación numérica que indica su importancia. Estas respuestas intermedias generadas son las Respuestas intermedias calificadas (Respuesta intermedia calificada 1, Respuesta 2... Respuesta N).
Clasificación y filtrado: El sistema clasifica y filtra estas respuestas intermedias, seleccionando los puntos más importantes. Los puntos importantes seleccionados forman las Respuestas intermedias agregadas.
Respuesta final: Las respuestas intermedias agregadas se utilizan como contexto para generar la respuesta final.
Cuando los usuarios hacen preguntas sobre entidades específicas (como nombres de personas, lugares, organizaciones, etc.), recomendamos que utilice el flujo de trabajo de búsqueda local. Este proceso incluye los siguientes pasos:
Figura 3- Flujo de datos de búsqueda local
Figura 3: Flujo de datos de búsqueda local (Fuente de la imagen: Microsoft Research)
Consulta del usuario: Primero, el sistema recibe una consulta del usuario, que podría ser una pregunta simple o una consulta más compleja.
Búsqueda de entidades similares: El sistema identifica un conjunto de entidades del grafo de conocimiento que están relacionadas semánticamente con la entrada del usuario. Estas entidades sirven como puntos de entrada al grafo de conocimiento. Este paso utiliza una base de datos vectorial como Milvus para realizar búsquedas de similitud de texto.
Mapeo de entidades a unidades de texto: Las unidades de texto extraídas se mapean a las entidades correspondientes, eliminando la información de texto original.
Extracción de entidades y relaciones: Este paso extrae información específica sobre las entidades y sus relaciones correspondientes.
Mapeo de entidades a covariables: Este paso mapea las entidades a sus covariables, que pueden incluir datos estadísticos u otros atributos relevantes.
Mapeo de entidades a informes de comunidad: Los informes de comunidad se integran en los resultados de búsqueda, incorporando cierta información global.
Utilización del historial de conversación: Si se proporciona, el sistema utiliza el historial de conversación para comprender mejor la intención y el contexto del usuario.
Generación de respuestas: Finalmente, el sistema construye una respuesta a la consulta del usuario basándose en los datos filtrados y ordenados generados en los pasos anteriores.
RAG de referencia vs. GraphRAG en la calidad de salida
Para mostrar la eficacia de GraphRAG, sus creadores comparan la calidad de salida de un RAG de referencia y GraphRAG en su blog de anuncio. Citaré aquí un ejemplo sencillo a modo de ilustración.
Dataset utilizado
Los creadores de GraphRAG utilizaron el dataset Violent Incident Information from News Articles (VIINA) para sus experimentos.
Nota: Este dataset contiene temas sensibles. Fue elegido únicamente debido a su complejidad y a la presencia de opiniones divergentes e información parcial. Es un caso de prueba desordenado del mundo real que era lo suficientemente reciente como para no estar incluido en el entrenamiento del modelo base del LLM.
Resumen del experimento
Tanto el RAG de referencia como GraphRAG recibieron la misma pregunta, que requiere agregar información de todo el dataset para componer una respuesta.
P: ¿Cuáles son los 5 temas principales del dataset?
Las respuestas se muestran en la imagen de abajo. Los resultados del RAG de referencia fueron irrelevantes para los temas de la guerra, ya que la búsqueda vectorial recuperó texto no relacionado, lo que condujo a una evaluación inexacta. En cambio, GraphRAG proporcionó una respuesta clara y relevante, identificando los temas principales y los detalles de apoyo. Los resultados estaban alineados con el dataset, con referencias al material fuente.
Figura 4- RAG de referencia vs. GraphRAG al responder preguntas complejas de resumen
Figura 4: RAG de referencia vs. GraphRAG al responder preguntas complejas de resumen
Experimentos adicionales en el artículo “From Local to Global: A Graph RAG Approach to Query-Focused Summarization.” demuestran que GraphRAG mejora significativamente el razonamiento de múltiples saltos y la síntesis de información compleja. La investigación indica que GraphRAG supera al RAG de referencia tanto en exhaustividad como en diversidad:
Exhaustividad: La medida en que la respuesta cubre todos los aspectos de la pregunta.
Diversidad: La variedad y riqueza de perspectivas e ideas que proporciona la respuesta.
Te recomendamos leer el artículo original de GraphRAG para obtener más detalles sobre estos experimentos.
Cómo implementar GraphRAG con la base de datos vectorial Milvus
GraphRAG mejora las aplicaciones RAG con grafos de conocimiento y también depende de una base de datos vectorial para recuperar entidades relevantes. Esta sección demuestra cómo implementar GraphRAG, crear un índice GraphRAG y consultarlo utilizando la base de datos vectorial Milvus.
Requisitos previos
Antes de ejecutar el código de este blog, asegúrate de haber instalado las siguientes dependencias:
pip install --upgrade pymilvus
pip install git+https://github.com/zc277584121/graphrag.git
Nota: Instalamos GraphRAG desde un repositorio bifurcado porque la función de almacenamiento de Milvus todavía está pendiente de una fusión oficial al momento de escribir esto.
Comencemos con el flujo de trabajo de indexación.
Preparación de datos
Descarga un pequeño archivo de texto con unas mil líneas de Project Gutenberg y úsalo para la indexación de GraphRAG.
Este conjunto de datos trata sobre la historia de Leonardo Da Vinci. Usamos GraphRAG para crear un índice de grafo de todas las relaciones relacionadas con Da Vinci y la base de datos vectorial Milvus para buscar conocimiento relevante con el fin de responder preguntas.
import nest_asyncio
nest_asyncio.apply()
import os
import urllib.request
index_root = os.path.join(os.getcwd(), 'graphrag_index')
os.makedirs(os.path.join(index_root, 'input'), exist_ok=True)
url = "https://www.gutenberg.org/cache/epub/7785/pg7785.txt"
file_path = os.path.join(index_root, 'input', 'davinci.txt')
urllib.request.urlretrieve(url, file_path)
with open(file_path, 'r+', encoding='utf-8') as file:
# We use the first 934 lines of the text file, because the later lines are not relevant for this example.
# If you want to save api key cost, you can truncate the text file to a smaller size.
lines = file.readlines()
file.seek(0)
file.writelines(lines[:934]) # Decrease this number if you want to save api key cost.
file.truncate()
Inicializar el espacio de trabajo
Ahora, usemos GraphRAG para indexar el archivo de texto. Para inicializar tu espacio de trabajo, primero ejecutemos el comando graphrag.index --init.
python -m graphrag.index --init --root ./graphrag_index
Configurar el archivo env y los ajustes
Encontrarás el archivo .env en el directorio raíz del índice. Para usarlo, añade tu clave de API de OpenAI al archivo .env.
Notas importantes: __
Usaremos modelos de OpenAI para este ejemplo; asegúrate de tener una clave de API lista.
La indexación de GraphRAG es costosa, ya que procesa todo el corpus de texto con LLMs. Ejecutar esta demostración puede costar unos pocos dólares. Para ahorrar dinero, considera truncar el archivo de texto a un tamaño más pequeño.
Ejecutar la canalización de indexación
El proceso de indexación llevará algo de tiempo. Una vez completado, encontrarás una nueva carpeta en ./graphrag_index/output/<timestamp>/artifacts que contiene una serie de archivos parquet.
python -m graphrag.index --root ./graphrag_index
Consultar con la base de datos vectorial Milvus
Durante la etapa de consulta, usamos Milvus para almacenar embeddings de descripciones de entidades para la búsqueda local de GraphRAG. Este método combina datos estructurados del grafo de conocimiento con datos no estructurados de los documentos de entrada, enriqueciendo el contexto del LLM con información relevante de entidades para obtener respuestas más precisas.
import os
import pandas as pd
import tiktoken
from graphrag.query.context_builder.entity_extraction import EntityVectorStoreKey
from graphrag.query.indexer_adapters import (
# read_indexer_covariates,
read_indexer_entities,
read_indexer_relationships,
read_indexer_reports,
read_indexer_text_units,
)
from graphrag.query.input.loaders.dfs import (
store_entity_semantic_embeddings,
)
from graphrag.query.llm.oai.chat_openai import ChatOpenAI
from graphrag.query.llm.oai.embedding import OpenAIEmbedding
from graphrag.query.llm.oai.typing import OpenaiApiType
from graphrag.query.question_gen.local_gen import LocalQuestionGen
from graphrag.query.structured_search.local_search.mixed_context import (
LocalSearchMixedContext,
)
from graphrag.query.structured_search.local_search.search import LocalSearch
from graphrag.vector_stores import MilvusVectorStore
output_dir = os.path.join(index_root, "output")
subdirs = [os.path.join(output_dir, d) for d in os.listdir(output_dir)]
latest_subdir = max(subdirs, key=os.path.getmtime) # Obtener el directorio de salida más reciente
INPUT_DIR = os.path.join(latest_subdir, "artifacts")
COMMUNITY_REPORT_TABLE = "create_final_community_reports"
ENTITY_TABLE = "create_final_nodes"
ENTITY_EMBEDDING_TABLE = "create_final_entities"
RELATIONSHIP_TABLE = "create_final_relationships"
COVARIATE_TABLE = "create_final_covariates"
TEXT_UNIT_TABLE = "create_final_text_units"
COMMUNITY_LEVEL = 2
Cargar datos del proceso de indexación
Durante el proceso de indexación, se generarán algunos archivos parquet. Los cargamos en memoria y almacenamos la información de descripción de entidades en la base de datos vectorial Milvus.
Leer entidades:
# leer la tabla de nodos para obtener datos de comunidad y grado
entity_df = pd.read_parquet(f"{INPUT_DIR}/{ENTITY_TABLE}.parquet")
entity_embedding_df = pd.read_parquet(f"{INPUT_DIR}/{ENTITY_EMBEDDING_TABLE}.parquet")
entities = read_indexer_entities(entity_df, entity_embedding_df, COMMUNITY_LEVEL)
description_embedding_store = MilvusVectorStore(
collection_name="entity_description_embeddings",
)
# description_embedding_store.connect(uri="http://localhost:19530") # Para el servicio docker de Milvus
description_embedding_store.connect(uri="./milvus.db") # Para Milvus Lite
entity_description_embeddings = store_entity_semantic_embeddings(
entities=entities, vectorstore=description_embedding_store
)
print(f"Recuento de entidades: {len(entity_df)}")
entity_df.head()
Recuento de entidades: 651
Figura 5: una captura de pantalla de entidades
Figura 5: una captura de pantalla de entidades
Leer relaciones
relationship_df = pd.read_parquet(f"{INPUT_DIR}/{RELATIONSHIP_TABLE}.parquet")
relationships = read_indexer_relationships(relationship_df)
print(f"Recuento de relaciones: {len(relationship_df)}")
relationship_df.head()
Recuento de relaciones: 290
Figura 6- una captura de pantalla de relaciones
Figura 6: una captura de pantalla de relaciones
Leer informes de comunidad
report_df = pd.read_parquet(f"{INPUT_DIR}/{COMMUNITY_REPORT_TABLE}.parquet")
reports = read_indexer_reports(report_df, entity_df, COMMUNITY_LEVEL)
print(f"Registros de informes: {len(report_df)}")
report_df.head()
Registros de informes: 45
Figura 7- una captura de pantalla de registros de informes
Figura 7: una captura de pantalla de registros de informes
Leer unidades de texto
text_unit_df = pd.read_parquet(f"{INPUT_DIR}/{TEXT_UNIT_TABLE}.parquet")
text_units = read_indexer_text_units(text_unit_df)
print(f"Registros de unidades de texto: {len(text_unit_df)}")
text_unit_df.head()
Registros de unidades de texto: 51
Figura 8- una captura de pantalla de registros de unidades de texto
Figura 8: una captura de pantalla de registros de unidades de texto
Crear un motor de búsqueda local
Hemos preparado los datos necesarios para el motor de búsqueda local. Ahora podemos crear una instancia de LocalSearch con ellos, un LLM y un modelo de embeddings.
Hemos preparado los datos necesarios para el motor de búsqueda local. Ahora podemos crear una instancia de LocalSearch con ellos, un LLM y un modelo de embeddings.
api_key = os.environ["OPENAI_API_KEY"] # Tu clave de API de OpenAI
llm_model = "gpt-4o" # O gpt-4-turbo-preview
embedding_model = "text-embedding-3-small"
llm = ChatOpenAI(
api_key=api_key,
model=llm_model,
api_type=OpenaiApiType.OpenAI,
max_retries=20,
)
token_encoder = tiktoken.get_encoding("cl100k_base")
text_embedder = OpenAIEmbedding(
api_key=api_key,
api_base=None,
api_type=OpenaiApiType.OpenAI,
model=embedding_model,
deployment_name=embedding_model,
max_retries=20,
)
context_builder = LocalSearchMixedContext(
community_reports=reports,
text_units=text_units,
entities=entities,
relationships=relationships,
covariates=None, #covariates,#pendiente
entity_text_embeddings=description_embedding_store,
embedding_vectorstore_key=EntityVectorStoreKey.ID, # si vectorstore usa el título de la entidad como ids, establece esto en EntityVectorStoreKey.TITLE
text_embedder=text_embedder,
token_encoder=token_encoder,
)
local_context_params = {
"text_unit_prop": 0.5,
"community_prop": 0.1,
"conversation_history_max_turns": 5,
"conversation_history_user_turns_only": True,
"top_k_mapped_entities": 10,
"top_k_relationships": 10,
"include_entity_rank": True,
"include_relationship_weight": True,
"include_community_rank": False,
"return_candidate_context": False,
"embedding_vectorstore_key": EntityVectorStoreKey.ID, # establece esto en EntityVectorStoreKey.TITLE si vectorstore usa el título de la entidad como ids
"max_tokens": 12_000, # cambia esto según el límite de tokens que tengas en tu modelo (si estás usando un modelo con límite de 8k, una buena configuración podría ser 5000)
}
llm_params = {
"max_tokens": 2_000, # cambia esto según el límite de tokens que tengas en tu modelo (si estás usando un modelo con límite de 8k, una buena configuración podría ser 1000=1500)
"temperature": 0.0,
}
search_engine = LocalSearch(
llm=llm,
context_builder=context_builder,
token_encoder=token_encoder,
llm_params=llm_params,
context_builder_params=local_context_params,
response_type="múltiples párrafos", # texto de formato libre que describe el tipo y formato de la respuesta, puede ser cualquier cosa, p. ej., lista priorizada, párrafo único, múltiples párrafos, informe de varias páginas
)
Haz una consulta.
result = await search_engine.asearch("Háblame sobre Leonardo Da Vinci")
print(result.response)
# Leonardo da Vinci
Leonardo da Vinci, nacido en 1452 en la localidad de Vinci, cerca de Florencia, es ampliamente celebrado como uno de los genios más versátiles del Renacimiento italiano. Su nombre completo era Leonardo di Ser Piero d'Antonio di Ser Piero di Ser Guido da Vinci, y fue el hijo natural y primogénito de Ser Piero, un notario rural [Data: Entities (0)]. Las contribuciones de Leonardo abarcaron diversos campos, incluidos el arte, la ciencia, la ingeniería y la filosofía, lo que le valió el título del Genio más Universal de los tiempos cristianos [Data: Entities (8)].
## Primeros años y formación
La temprana promesa de Leonardo fue reconocida por su padre, quien llevó algunos de sus dibujos a Andrea del Verrocchio, un renombrado artista y escultor. Impresionado por el talento de Leonardo, Verrocchio lo aceptó en su taller alrededor de 1469-1470. Allí, Leonardo conoció a otros artistas notables, incluidos Botticelli y Lorenzo di Credi [Data: Sources (6, 7)]. Para 1472, Leonardo fue admitido en el Gremio de Pintores Florentinos, marcando el inicio de su carrera profesional [Data: Sources (7)].
## Obras maestras artísticas
Leonardo es quizás más conocido por sus pinturas icónicas, como la "Mona Lisa" y "La última cena." La "Mona Lisa," reconocida por su expresión sutil y su fondo detallado, se encuentra en el Louvre y sigue siendo una de las obras de arte más famosas del mundo [Data: Relationships (0, 45)]. "La última cena," un fresco que representa el momento en que Jesús anunció que uno de sus discípulos lo traicionaría, se encuentra en el refectorio de Santa Maria delle Grazie en Milán [Data: Sources (2)]. Otras obras significativas incluyen "La Virgen de las Rocas" y el "Tratado de pintura," que comenzó alrededor de 1489-1490 [Data: Relationships (7, 12)].
## Contribuciones científicas y de ingeniería
El genio de Leonardo se extendió más allá del arte a diversas empresas científicas y de ingeniería. Realizó observaciones significativas en anatomía, óptica e hidráulica, y sus cuadernos están llenos de bocetos e ideas que anticiparon muchos inventos modernos. Por ejemplo, anticipó la teoría de Copérnico sobre el movimiento de la Tierra y la clasificación de los animales de Lamarck [Data: Relationships (38, 39)]. Su trabajo sobre las leyes de la luz y la sombra y su dominio del claroscuro tuvieron un profundo impacto tanto en el arte como en la ciencia [Data: Sources (45)].
## Mecenazgo y relaciones profesionales
La carrera de Leonardo estuvo significativamente influida por sus mecenas. Ludovico Sforza, el duque de Milán, empleó a Leonardo como pintor de la corte y artífice general, encargándole diversas obras e incluso regalándole un viñedo en 1499 [Data: Relationships (9, 19, 84)]. En sus últimos años, Leonardo se trasladó a Francia bajo el mecenazgo del rey Francisco I, quien le proporcionó una renta principesca y lo tenía en alta estima [Data: Relationships (114, 37)]. Leonardo pasó sus últimos años en la Casa Señorial de Cloux, cerca de Amboise, donde recibía frecuentes visitas del rey y contaba con el apoyo de su íntimo amigo y asistente, Francesco Melzi [Data: Relationships (28, 122)].
## Legado e influencia
La influencia de Leonardo da Vinci se extendió mucho más allá de su vida. Fundó una Escuela de pintura en Milán, y sus técnicas y enseñanzas fueron continuadas por sus estudiantes y seguidores, como Giovanni Ambrogio da Predis y Francesco Melzi [Data: Relationships (6, 15, 28)]. Sus obras continúan siendo celebradas y estudiadas, consolidando su legado como uno de los más grandes maestros del Renacimiento. La capacidad de Leonardo para combinar el arte y la ciencia ha dejado una marca indeleble en ambos campos, inspirando a innumerables generaciones de artistas y científicos [Data: Entities (148, 86); Relationships (27, 12)].
En resumen, las contribuciones incomparables de Leonardo da Vinci al arte, la ciencia y la ingeniería, combinadas con su pensamiento innovador y su profunda influencia en sus contemporáneos y en las generaciones futuras, lo convierten en una figura colosal en la historia de los logros humanos. Su legado continúa inspirando admiración y estudio, subrayando la relevancia atemporal de su genio.
Los resultados de GraphRAG son específicos, con las fuentes de datos citadas claramente marcadas.
Generación de preguntas
GraphRAG también puede generar preguntas basadas en consultas históricas, lo cual es útil para crear preguntas recomendadas en un diálogo de chatbot. Este método combina datos estructurados del grafo de conocimiento con datos no estructurados de documentos de entrada para producir preguntas candidatas relacionadas con entidades específicas.
question_generator = LocalQuestionGen(
llm=llm,
context_builder=context_builder,
token_encoder=token_encoder,
llm_params=llm_params,
context_builder_params=local_context_params,
)
question_history = [
"Tell me about Leonardo Da Vinci",
"Leonardo's early works",
]
Genera preguntas basadas en el historial.
candidate_questions = await question_generator.agenerate(
question_history=question_history, context_data=None, question_count=5
)
candidate_questions.response
["- What were some of Leonardo da Vinci's early works and where are they housed?",
"- How did Leonardo da Vinci's relationship with Andrea del Verrocchio influence his early works?",
'- What notable projects did Leonardo da Vinci undertake during his time in Milan?',
"- How did Leonardo da Vinci's engineering skills contribute to his projects?",
"- What was the significance of Leonardo da Vinci's relationship with Francis I of France?"]
Puedes eliminar la raíz del índice si quieres borrar el índice para ahorrar espacio.
# import shutil
#
# shutil.rmtree(index_root)
Resumen
En este blog, exploramos GraphRAG, un método innovador que mejora la tecnología RAG al integrar grafos de conocimiento. GraphRAG es ideal para abordar tareas complejas como el razonamiento de múltiples saltos y responder preguntas integrales que requieren vincular piezas de información dispares.
Cuando se combina con la base de datos vectorial Milvus, GraphRAG puede navegar por relaciones semánticas intrincadas dentro de grandes conjuntos de datos, proporcionando resultados más precisos y reveladores. Esta poderosa combinación convierte a GraphRAG en un recurso invaluable para diversas aplicaciones prácticas de GenAI, proporcionando una solución robusta para comprender y procesar información compleja.
Recursos adicionales
El artículo de GraphRAG: De lo local a lo global: un enfoque Graph RAG para la resumición centrada en consultas
GitHub de GraphRAG: https://github.com/microsoft/graphrag
Otras técnicas de mejora de RAG:
Sigue leyendo
How to Use Anthropic MCP Server with Milvus
MCP + Milvus: Streamline AI agent development with standardized data access, eliminating integration hassles while enhancing context and flexibility.
Bringing AI to Legal Tech: The Role of Vector Databases in Enhancing LLM Guardrails
Discover how vector databases enhance AI reliability in legal tech, ensuring accurate, compliant, and trustworthy AI-powered legal solutions.
Why Deepseek is Waking up AI Giants Like OpenAI And Why You Should Care
Discover how DeepSeek R1's open-source AI model with superior reasoning capabilities and lower costs is disrupting the AI landscape and challenging tech giants like OpenAI.