GraphRAG expliqué : améliorer le RAG avec des graphes de connaissances
Introduction à RAG et à ses défis
Retrieval Augmented Generation (RAG) est une technique qui connecte des sources de données externes afin d’améliorer la sortie des grands modèles de langage (LLMs). Cette technique est idéale pour permettre aux LLMs d’accéder à des données privées ou propres à un domaine et de résoudre les problèmes d’hallucination. Par conséquent, RAG a été largement utilisé pour alimenter de nombreuses applications GenAI, telles que les chatbots IA et les systèmes de recommandation.
Un RAG de base intègre généralement une base de données vectorielle et un LLM, où la base de données vectorielle stocke et récupère des informations contextuelles pour les requêtes des utilisateurs, et où le LLM génère des réponses en fonction du contexte récupéré. Bien que cette approche fonctionne bien dans de nombreux cas, elle peine à gérer des tâches complexes comme le raisonnement multi-sauts ou à répondre à des questions qui nécessitent de relier des éléments d’information disparates.
Par exemple, considérez cette question : « Quel nom a été donné au fils de l’homme qui a vaincu l’usurpateur Allectus ?”
Un RAG de base suivrait généralement ces étapes pour répondre à cette question :
Identifier l’homme : Déterminer qui a vaincu Allectus.
Rechercher le fils de l’homme : Rechercher des informations sur la famille de cette personne, en particulier son fils.
Trouver le nom : Identifier le nom du fils.
Le défi se pose généralement dès la première étape, car un RAG de base récupère du texte en fonction de la similarité sémantique, sans répondre directement aux requêtes complexes dans lesquelles des détails spécifiques peuvent ne pas être explicitement mentionnés dans le jeu de données. Cette limitation rend difficile la recherche de l’information exacte nécessaire, nécessitant souvent des solutions coûteuses et peu pratiques, comme la création manuelle de paires Q&R pour les requêtes fréquentes.
Pour relever de tels défis, Microsoft Research a introduit GraphRAG, une toute nouvelle méthode qui enrichit la récupération et la génération RAG avec des graphes de connaissances. Dans les sections suivantes, nous expliquerons comment GraphRAG fonctionne en coulisses et comment l’exécuter avec la base de données vectorielle Milvus .
Qu’est-ce que GraphRAG et comment fonctionne-t-il ?
Contrairement à un RAG de base qui utilise une base de données vectorielle pour récupérer du texte sémantiquement similaire, GraphRAG améliore RAG en intégrant des graphes de connaissances (KGs). Les graphes de connaissances sont des structures de données qui stockent et relient des données liées ou non liées en fonction de leurs relations.
Un pipeline GraphRAG se compose généralement de deux processus fondamentaux : l’indexation et l’interrogation.
Le pipeline GraphRAG
Le pipeline GraphRAG (Source de l’image : Article GraphRAG)
Indexation
Le processus d’indexation comprend quatre étapes clés :
Segmentation en unités de texte : L’ensemble du corpus d’entrée est divisé en plusieurs unités de texte (segments de texte). Ces segments sont les plus petites unités analysables et peuvent être des paragraphes, des phrases ou d’autres unités logiques. En segmentant de longs documents en segments plus petits, nous pouvons extraire et préserver des informations plus détaillées sur ces données d’entrée.
Extraction des entités, des relations et des affirmations : GraphRAG utilise des LLMs pour identifier et extraire toutes les entités (noms de personnes, de lieux, d’organisations, etc.), les relations entre elles et les affirmations clés exprimées dans le texte de chaque unité de texte. Nous utiliserons ces informations extraites pour construire un graphe de connaissances initial.
Clustering hiérarchique: GraphRAG utilise la technique Leiden pour effectuer un clustering hiérarchique sur les graphes de connaissances initiaux. Leiden est un algorithme de détection de communautés qui peut découvrir efficacement les structures communautaires au sein du graphe. Les entités de chaque cluster sont assignées à différentes communautés pour une analyse plus approfondie.
Remarque : Une communauté est un groupe de nœuds au sein du graphe qui sont densément connectés les uns aux autres, mais faiblement connectés aux autres groupes denses du réseau.
- Génération de résumés de communautés: GraphRAG génère des résumés pour chaque communauté et ses membres à l’aide d’une approche ascendante. Ces résumés incluent les principales entités au sein de la communauté, leurs relations et les affirmations clés. Cette étape donne un aperçu de l’ensemble du jeu de données et fournit des informations contextuelles utiles pour les requêtes ultérieures.
Figure 1- Un graphe de connaissances généré par un LLM construit à l’aide de GPT-4 Turbo.
Figure 1 : Un graphe de connaissances généré par un LLM construit à l’aide de GPT-4 Turbo.
(Source de l’image : Microsoft Research)
Interrogation
GraphRAG dispose de deux workflows d’interrogation différents adaptés à différentes requêtes.
Global Search pour raisonner sur des questions globales liées à l’ensemble du corpus de données en exploitant les résumés de communautés.
Local Search pour raisonner sur des entités spécifiques en s’étendant à leurs voisins et concepts associés.
Ce workflow de recherche globale comprend les phases suivantes.
Figure 2- Flux de données de recherche globale
Figure 2 : Flux de données de recherche globale (Source de l’image : Microsoft Research)
Requête utilisateur et historique de conversation: Le système prend la requête utilisateur et l’historique de conversation comme entrée initiale.
Lots de rapports de communautés: Le système utilise comme données contextuelles les rapports de communautés de nœuds générés par le LLM à partir d’un niveau spécifié de la hiérarchie des communautés. Ces rapports de communautés sont mélangés et divisés en plusieurs lots (Lot de rapports de communautés mélangé 1, Lot 2... Lot N).
RIR (Réponses intermédiaires notées): Chaque lot de rapports de communautés est ensuite divisé en fragments de texte de taille prédéfinie. Chaque fragment de texte est utilisé pour générer une réponse intermédiaire. La réponse contient une liste d’éléments d’information appelés points. Chaque point possède un score numérique indiquant son importance. Ces réponses intermédiaires générées sont les Réponses intermédiaires notées (Réponse intermédiaire notée 1, Réponse 2... Réponse N).
Classement et filtrage: Le système classe et filtre ces réponses intermédiaires, en sélectionnant les points les plus importants. Les points importants sélectionnés forment les Réponses intermédiaires agrégées.
Réponse finale: Les réponses intermédiaires agrégées sont utilisées comme contexte pour générer la réponse finale.
Lorsque les utilisateurs posent des questions sur des entités spécifiques (telles que des noms de personnes, de lieux, d’organisations, etc.), nous vous recommandons d’utiliser le workflow de recherche locale. Ce processus comprend les étapes suivantes :
Figure 3- Flux de données de recherche locale
Figure 3 : Flux de données de recherche locale (Source de l’image : Microsoft Research)
Requête utilisateur: Tout d’abord, le système reçoit une requête utilisateur, qui peut être une question simple ou une requête plus complexe.
Recherche d’entités similaires : Le système identifie un ensemble d’entités du graphe de connaissances qui sont sémantiquement liées à l’entrée utilisateur. Ces entités servent de points d’entrée dans le graphe de connaissances. Cette étape utilise une base de données vectorielle comme Milvus pour effectuer des recherches de similarité textuelle.
Mappage entité-unité de texte : Les unités de texte extraites sont mappées aux entités correspondantes, en supprimant les informations textuelles d’origine.
Extraction entité-relation : Cette étape extrait des informations spécifiques sur les entités et leurs relations correspondantes.
Mappage entité-covariable : Cette étape mappe les entités à leurs covariables, qui peuvent inclure des données statistiques ou d’autres attributs pertinents.
Mappage entité-rapport de communauté : Les rapports de communauté sont intégrés aux résultats de recherche, incorporant certaines informations globales.
Utilisation de l’historique de conversation : S’il est fourni, le système utilise l’historique de conversation pour mieux comprendre l’intention et le contexte de l’utilisateur.
Génération de réponse : Enfin, le système construit et renvoie une réponse à la requête utilisateur sur la base des données filtrées et triées générées lors des étapes précédentes.
RAG de référence vs. GraphRAG en qualité de sortie
Pour démontrer l’efficacité de GraphRAG, ses créateurs comparent la qualité de sortie d’un RAG de référence et de GraphRAG dans leur billet d’annonce. Je citerai ici un exemple simple à titre d’illustration.
Jeu de données utilisé
Les créateurs de GraphRAG ont utilisé le jeu de données Violent Incident Information from News Articles (VIINA) pour leurs expériences.
Remarque : Ce jeu de données contient des sujets sensibles. Il a été choisi uniquement en raison de sa complexité et de la présence d’opinions divergentes et d’informations partielles. Il s’agit d’un cas de test réel désordonné, suffisamment récent pour ne pas avoir été inclus dans l’entraînement du modèle de base du LLM.
Aperçu de l’expérience
Le RAG de référence et GraphRAG se sont vu poser la même question, qui nécessite d’agréger des informations à travers le jeu de données pour composer une réponse.
Q : Quels sont les 5 principaux thèmes du jeu de données ?
Les réponses sont présentées dans l’image ci-dessous. Les résultats du RAG de référence n’étaient pas pertinents par rapport aux thèmes de la guerre, car la recherche vectorielle a récupéré du texte sans rapport, conduisant à une évaluation inexacte. En revanche, GraphRAG a fourni une réponse claire et pertinente, identifiant les principaux thèmes et les détails à l’appui. Les résultats étaient alignés avec le jeu de données, avec des références au matériel source.
Figure 4- RAG de référence vs. GraphRAG dans la réponse à des questions complexes de synthèse
Figure 4 : RAG de référence vs. GraphRAG dans la réponse à des questions complexes de synthèse
D’autres expériences dans l’article “From Local to Global: A Graph RAG Approach to Query-Focused Summarization.” démontrent que GraphRAG améliore considérablement le raisonnement multi-sauts et la synthèse d’informations complexes. La recherche indique que GraphRAG surpasse le RAG de référence à la fois en exhaustivité et en diversité :
Exhaustivité : La mesure dans laquelle la réponse couvre tous les aspects de la question.
Diversité : La variété et la richesse des perspectives et des insights que la réponse fournit.
Nous vous recommandons de lire l’article original sur GraphRAG pour obtenir plus de détails sur ces expériences.
Comment implémenter GraphRAG avec la base de données vectorielle Milvus
GraphRAG améliore les applications RAG avec des graphes de connaissances et s’appuie également sur une base de données vectorielle pour récupérer les entités pertinentes. Cette section montre comment implémenter GraphRAG, créer un index GraphRAG et l’interroger à l’aide de la base de données vectorielle Milvus.
Prérequis
Avant d’exécuter le code de ce blog, assurez-vous d’avoir installé les dépendances suivantes :
pip install --upgrade pymilvus
pip install git+https://github.com/zc277584121/graphrag.git
Remarque : Nous avons installé GraphRAG depuis un dépôt forké, car la fonctionnalité de stockage Milvus est encore en attente d’une fusion officielle au moment de la rédaction.
Commençons par le flux de travail d’indexation.
Préparation des données
Téléchargez un petit fichier texte d’environ mille lignes depuis Project Gutenberg et utilisez-le pour l’indexation GraphRAG.
Ce jeu de données porte sur l’histoire de Léonard de Vinci. Nous utilisons GraphRAG pour créer un index de graphe de toutes les relations liées à De Vinci, et la base de données vectorielle Milvus pour rechercher les connaissances pertinentes afin de répondre aux questions.
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()
Initialiser l’espace de travail
Maintenant, utilisons GraphRAG pour indexer le fichier texte. Pour initialiser votre espace de travail, exécutons d’abord la commande graphrag.index --init.
python -m graphrag.index --init --root ./graphrag_index
Configurer le fichier env et les paramètres
Vous trouverez le fichier .env dans le répertoire racine de l’index. Pour l’utiliser, ajoutez votre clé API OpenAI au fichier .env.
Notes importantes : __
Nous utiliserons les modèles OpenAI pour cet exemple ; assurez-vous d’avoir une clé API prête.
L’indexation GraphRAG est coûteuse, car elle traite l’ensemble du corpus textuel avec des LLM. L’exécution de cette démonstration peut coûter quelques dollars. Pour économiser de l’argent, envisagez de tronquer le fichier texte à une taille plus petite.
Exécuter le pipeline d’indexation
Le processus d’indexation prendra un certain temps. Une fois terminé, vous trouverez un nouveau dossier à ./graphrag_index/output/<timestamp>/artifacts contenant une série de fichiers parquet.
python -m graphrag.index --root ./graphrag_index
Interroger avec la base de données vectorielle Milvus
Lors de l’étape d’interrogation, nous utilisons Milvus pour stocker les embeddings de descriptions d’entités pour la recherche locale GraphRAG. Cette méthode combine les données structurées du graphe de connaissances avec les données non structurées des documents d’entrée, enrichissant le contexte du LLM avec des informations pertinentes sur les entités pour des réponses plus précises.
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) # Get latest output directory
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
Charger les données issues du processus d’indexation
Pendant le processus d’indexation, quelques fichiers parquet seront générés. Nous les chargeons en mémoire et stockons les informations de description des entités dans la base de données vectorielle Milvus.
Lire les entités :
# read nodes table to get community and degree data
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") # For Milvus docker service
description_embedding_store.connect(uri="./milvus.db") # For Milvus Lite
entity_description_embeddings = store_entity_semantic_embeddings(
entities=entities, vectorstore=description_embedding_store
)
print(f"Entity count: {len(entity_df)}")
entity_df.head()
Nombre d’entités : 651
Figure 5 : une capture d’écran des entités
Figure 5 : une capture d’écran des entités
Lire les relations
relationship_df = pd.read_parquet(f"{INPUT_DIR}/{RELATIONSHIP_TABLE}.parquet")
relationships = read_indexer_relationships(relationship_df)
print(f"Relationship count: {len(relationship_df)}")
relationship_df.head()
Nombre de relations : 290
Figure 6- une capture d’écran des relations
Figure 6 : une capture d’écran des relations
Lire les rapports de communauté
report_df = pd.read_parquet(f"{INPUT_DIR}/{COMMUNITY_REPORT_TABLE}.parquet")
reports = read_indexer_reports(report_df, entity_df, COMMUNITY_LEVEL)
print(f"Report records: {len(report_df)}")
report_df.head()
Enregistrements de rapport : 45
Figure 7- une capture d’écran des enregistrements de rapport
Figure 7 : une capture d’écran des enregistrements de rapport
Lire les unités de texte
text_unit_df = pd.read_parquet(f"{INPUT_DIR}/{TEXT_UNIT_TABLE}.parquet")
text_units = read_indexer_text_units(text_unit_df)
print(f"Text unit records: {len(text_unit_df)}")
text_unit_df.head()
Enregistrements d’unités de texte : 51
Figure 8- une capture d’écran des enregistrements d’unités de texte
Figure 8 : une capture d’écran des enregistrements d’unités de texte
Créer un moteur de recherche local
Nous avons préparé les données nécessaires pour le moteur de recherche local. Maintenant, nous pouvons créer une instance LocalSearch avec celles-ci, un LLM et un modèle d’embedding.
Nous avons préparé les données nécessaires pour le moteur de recherche local. Maintenant, nous pouvons créer une instance LocalSearch avec celles-ci, un LLM et un modèle d’embedding.
api_key = os.environ["OPENAI_API_KEY"] # Your OpenAI API key
llm_model = "gpt-4o" # Or 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,#à faire
entity_text_embeddings=description_embedding_store,
embedding_vectorstore_key=EntityVectorStoreKey.ID, # si le vectorstore utilise le titre de l’entité comme identifiants, définissez ceci sur 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, # définissez ceci sur EntityVectorStoreKey.TITLE si le vectorstore utilise le titre de l’entité comme identifiants
"max_tokens": 12_000, # modifiez ceci en fonction de la limite de jetons que vous avez sur votre modèle (si vous utilisez un modèle avec une limite de 8k, un bon réglage pourrait être 5000)
}
llm_params = {
"max_tokens": 2_000, # modifiez ceci en fonction de la limite de jetons que vous avez sur votre modèle (si vous utilisez un modèle avec une limite de 8k, un bon réglage pourrait être 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="plusieurs paragraphes", # texte libre décrivant le type et le format de la réponse, peut être n’importe quoi, p. ex. liste priorisée, paragraphe unique, plusieurs paragraphes, rapport de plusieurs pages
)
Faire une requête.
result = await search_engine.asearch("Parle-moi de Leonardo Da Vinci")
print(result.response)
# Leonardo da Vinci
Leonardo da Vinci, né en 1452 dans la ville de Vinci près de Florence, est largement célébré comme l’un des génies les plus polyvalents de la Renaissance italienne. Son nom complet était Leonardo di Ser Piero d'Antonio di Ser Piero di Ser Guido da Vinci, et il était le fils naturel et premier-né de Ser Piero, un notaire de campagne [Data: Entities (0)]. Les contributions de Leonardo ont couvert divers domaines, notamment l’art, la science, l’ingénierie et la philosophie, lui valant le titre de Génie le plus universel des temps chrétiens [Data: Entities (8)].
## Jeunesse et formation
Les promesses précoces de Leonardo furent reconnues par son père, qui apporta certains de ses dessins à Andrea del Verrocchio, un artiste et sculpteur renommé. Impressionné par le talent de Leonardo, Verrocchio l’accepta dans son atelier vers 1469-1470. Là, Leonardo rencontra d’autres artistes notables, notamment Botticelli et Lorenzo di Credi [Data: Sources (6, 7)]. En 1472, Leonardo fut admis dans la Guilde des peintres florentins, marquant le début de sa carrière professionnelle [Data: Sources (7)].
## Chefs-d’œuvre artistiques
Leonardo est peut-être surtout connu pour ses peintures emblématiques, telles que la « Mona Lisa » et « The Last Supper ». La « Mona Lisa », réputée pour son expression subtile et son arrière-plan détaillé, est conservée au Louvre et demeure l’une des œuvres d’art les plus célèbres au monde [Data: Relationships (0, 45)]. « The Last Supper », une fresque représentant le moment où Jésus annonça que l’un de ses disciples le trahirait, se trouve dans le réfectoire de Santa Maria delle Grazie à Milan [Data: Sources (2)]. Parmi ses autres œuvres importantes figurent « The Virgin of the Rocks » et le « Treatise on Painting », qu’il commença vers 1489-1490 [Data: Relationships (7, 12)].
## Contributions scientifiques et techniques
Le génie de Leonardo s’étendait au-delà de l’art à diverses entreprises scientifiques et techniques. Il fit des observations importantes en anatomie, en optique et en hydraulique, et ses carnets sont remplis de croquis et d’idées qui anticipaient de nombreuses inventions modernes. Par exemple, il anticipa la théorie de Copernic sur le mouvement de la Terre et la classification des animaux de Lamarck [Data: Relationships (38, 39)]. Ses travaux sur les lois de la lumière et de l’ombre, ainsi que sa maîtrise du clair-obscur, eurent un impact profond sur l’art comme sur la science [Data: Sources (45)].
## Mécénat et relations professionnelles
La carrière de Leonardo fut considérablement influencée par ses mécènes. Ludovico Sforza, le duc de Milan, employa Leonardo comme peintre de cour et artisan général, lui commandant diverses œuvres et lui offrant même un vignoble en 1499 [Data: Relationships (9, 19, 84)]. Dans ses dernières années, Leonardo s’installa en France sous le patronage du roi François Ier, qui lui assura un revenu princier et le tenait en haute estime [Data: Relationships (114, 37)]. Leonardo passa ses dernières années au manoir du Cloux près d’Amboise, où il recevait fréquemment la visite du roi et était soutenu par son ami proche et assistant, Francesco Melzi [Data: Relationships (28, 122)].
## Héritage et influence
L’influence de Leonardo da Vinci s’étendit bien au-delà de sa vie. Il fonda une école de peinture à Milan, et ses techniques et enseignements furent transmis par ses élèves et disciples, tels que Giovanni Ambrogio da Predis et Francesco Melzi [Data: Relationships (6, 15, 28)]. Ses œuvres continuent d’être célébrées et étudiées, consolidant son héritage comme l’un des plus grands maîtres de la Renaissance. La capacité de Leonardo à mêler art et science a laissé une marque indélébile dans ces deux domaines, inspirant d’innombrables générations d’artistes et de scientifiques [Data: Entities (148, 86); Relationships (27, 12)].
En résumé, les contributions sans égal de Leonardo da Vinci à l’art, à la science et à l’ingénierie, combinées à sa pensée innovante et à son influence profonde sur ses contemporains et les générations futures, font de lui une figure majeure de l’histoire des accomplissements humains. Son héritage continue d’inspirer l’admiration et l’étude, soulignant la pertinence intemporelle de son génie.
Les résultats de GraphRAG sont spécifiques, avec des sources de données citées clairement indiquées.
Génération de questions
GraphRAG peut également générer des questions basées sur des requêtes historiques, ce qui est utile pour créer des questions recommandées dans un dialogue de chatbot. Cette méthode combine des données structurées issues du graphe de connaissances avec des données non structurées provenant de documents d’entrée afin de produire des questions candidates liées à des entités spécifiques.
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",
]
Générez des questions basées sur l’historique.
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?"]
Vous pouvez supprimer la racine de l’index si vous souhaitez supprimer l’index afin d’économiser de l’espace.
# import shutil
#
# shutil.rmtree(index_root)
Résumé
Dans ce blog, nous avons exploré GraphRAG, une méthode innovante qui améliore la technologie RAG en intégrant des graphes de connaissances. GraphRAG est idéal pour traiter des tâches complexes telles que le raisonnement multi-sauts et répondre à des questions globales qui nécessitent de relier des éléments d’information disparates.
Associé à la base de données vectorielle Milvus, GraphRAG peut naviguer dans des relations sémantiques complexes au sein de grands ensembles de données, fournissant des résultats plus précis et plus éclairants. Cette combinaison puissante fait de GraphRAG un atout inestimable pour diverses applications pratiques de GenAI, en offrant une solution robuste pour comprendre et traiter des informations complexes.
Ressources complémentaires
L’article GraphRAG : From Local to Global: A Graph RAG Approach to Query-Focused Summarization
GitHub de GraphRAG : https://github.com/microsoft/graphrag
Autres techniques d’amélioration de RAG :
Continuer à lire
Zilliz Cloud Just Landed in Claude Code
The Zilliz Cloud Plugin brings the full power of Zilliz Cloud directly into your Claude Code terminal as natural-language conversations.
Expanding Our Global Reach: Zilliz Cloud Launches in Azure Central India
Zilliz Cloud expands to Azure Central India. This new region helps customers meet compliance, reduce latency, and optimize cloud costs when building AI applications.
Optimizing Embedding Model Selection with TDA Clustering: A Strategic Guide for Vector Databases
Discover how Topological Data Analysis (TDA) reveals hidden embedding model weaknesses and helps optimize vector database performance.