GraphRAG spiegato: potenziare RAG con i Knowledge Graphs
Introduzione a RAG e alle sue sfide
Retrieval Augmented Generation (RAG) è una tecnica che collega fonti di dati esterne per migliorare l'output dei large language models (LLM). Questa tecnica è perfetta per consentire agli LLM di accedere a dati privati o specifici di dominio e affrontare i problemi di hallucination. Pertanto, RAG è stato ampiamente utilizzato per alimentare molte applicazioni GenAI, come chatbot AI e sistemi di raccomandazione.
Un RAG di base di solito integra un database vettoriale e un LLM, dove il database vettoriale archivia e recupera informazioni contestuali per le query degli utenti, e l'LLM genera risposte in base al contesto recuperato. Sebbene questo approccio funzioni bene in molti casi, fatica con attività complesse come il ragionamento multi-hop o la risposta a domande che richiedono di collegare informazioni disparate.
Ad esempio, considera questa domanda: “Quale nome fu dato al figlio dell’uomo che sconfisse l’usurpatore Allectus?”
Un RAG di base seguirebbe generalmente questi passaggi per rispondere a questa domanda:
Identificare l’uomo: Determinare chi sconfisse Allectus.
Ricercare il figlio dell’uomo: Cercare informazioni sulla famiglia di questa persona, in particolare su suo figlio.
Trovare il nome: Identificare il nome del figlio.
La sfida di solito emerge nel primo passaggio perché un RAG di base recupera testo in base alla somiglianza semantica, non rispondendo direttamente a query complesse in cui dettagli specifici potrebbero non essere menzionati esplicitamente nel dataset. Questa limitazione rende difficile trovare le informazioni esatte necessarie, spesso richiedendo soluzioni costose e impraticabili come la creazione manuale di coppie Q&A per le query frequenti.
Per affrontare tali sfide, Microsoft Research ha introdotto GraphRAG, un metodo nuovissimo che potenzia il recupero e la generazione di RAG con grafi di conoscenza. Nelle sezioni seguenti, spiegheremo come GraphRAG funziona sotto il cofano e come eseguirlo con il database vettoriale Milvus .
Cos’è GraphRAG e come funziona?
A differenza di un RAG di base che utilizza un database vettoriale per recuperare testo semanticamente simile, GraphRAG potenzia RAG incorporando grafi di conoscenza (KG). I grafi di conoscenza sono strutture dati che archiviano e collegano dati correlati o non correlati in base alle loro relazioni.
Una pipeline GraphRAG di solito consiste in due processi fondamentali: indicizzazione e interrogazione.
La pipeline GraphRAG
La pipeline GraphRAG (Fonte immagine: Paper GraphRAG)
Indicizzazione
Il processo di indicizzazione include quattro passaggi chiave:
Segmentazione delle unità di testo: L’intero corpus di input viene diviso in più unità di testo (frammenti di testo). Questi frammenti sono le unità analizzabili più piccole e possono essere paragrafi, frasi o altre unità logiche. Segmentando documenti lunghi in frammenti più piccoli, possiamo estrarre e preservare informazioni più dettagliate su questi dati di input.
Estrazione di entità, relazioni e affermazioni: GraphRAG utilizza gli LLM per identificare ed estrarre tutte le entità (nomi di persone, luoghi, organizzazioni, ecc.), le relazioni tra esse e le affermazioni chiave espresse nel testo da ciascuna unità di testo. Useremo queste informazioni estratte per costruire un grafo di conoscenza iniziale.
Clustering gerarchico: GraphRAG utilizza la tecnica Leiden per eseguire il clustering gerarchico sui grafi di conoscenza iniziali. Leiden è un algoritmo di rilevamento delle community che può scoprire efficacemente le strutture di community all'interno del grafo. Le entità in ciascun cluster vengono assegnate a diverse community per un'analisi più approfondita.
Nota: Una community è un gruppo di nodi all'interno del grafo che sono densamente connessi tra loro ma scarsamente connessi ad altri gruppi densi nella rete.
- Generazione di riepiloghi delle community: GraphRAG genera riepiloghi per ciascuna community e i suoi membri utilizzando un approccio bottom-up. Questi riepiloghi includono le principali entità all'interno della community, le loro relazioni e le affermazioni chiave. Questo passaggio offre una panoramica dell'intero dataset e fornisce informazioni contestuali utili per le query successive.
Figura 1- Un grafo di conoscenza generato da un LLM creato utilizzando GPT-4 Turbo.
Figura 1: Un grafo di conoscenza generato da un LLM creato utilizzando GPT-4 Turbo.
(Fonte immagine: Microsoft Research)
Querying
GraphRAG dispone di due diversi workflow di querying adattati a query diverse.
Global Search per ragionare su domande olistiche relative all'intero corpus di dati sfruttando i riepiloghi delle community.
Local Search per ragionare su entità specifiche espandendosi verso i loro vicini e i concetti associati.
Questo workflow di ricerca globale include le seguenti fasi.
Figura 2- Flusso di dati della ricerca globale
Figura 2: Flusso di dati della ricerca globale (Fonte immagine: Microsoft Research)
Query utente e cronologia della conversazione: Il sistema prende la query utente e la cronologia della conversazione come input iniziale.
Batch di report delle community: Il sistema utilizza come dati di contesto i report delle community di nodi generati dall'LLM da un livello specificato della gerarchia delle community. Questi report delle community vengono mescolati e divisi in più batch (Batch di report delle community mescolati 1, Batch 2... Batch N).
RIR (Risposte intermedie valutate): Ogni batch di report delle community viene ulteriormente diviso in blocchi di testo di dimensioni predefinite. Ogni blocco di testo viene utilizzato per generare una risposta intermedia. La risposta contiene un elenco di elementi informativi chiamati punti. Ogni punto ha un punteggio numerico che indica la sua importanza. Queste risposte intermedie generate sono le Risposte intermedie valutate (Risposta intermedia valutata 1, Risposta 2... Risposta N).
Classificazione e filtraggio: Il sistema classifica e filtra queste risposte intermedie, selezionando i punti più importanti. I punti importanti selezionati formano le Risposte intermedie aggregate.
Risposta finale: Le risposte intermedie aggregate vengono utilizzate come contesto per generare la risposta finale.
Quando gli utenti pongono domande su entità specifiche (come nomi di persone, luoghi, organizzazioni, ecc.), ti consigliamo di utilizzare il workflow di ricerca locale. Questo processo include i seguenti passaggi:
Figura 3- Flusso di dati della ricerca locale
Figura 3: Flusso di dati della ricerca locale (Fonte immagine: Microsoft Research)
Query utente: Innanzitutto, il sistema riceve una query utente, che potrebbe essere una domanda semplice o una query più complessa.
Ricerca di entità simili: Il sistema identifica un insieme di entità dal knowledge graph che sono semanticamente correlate all'input dell'utente. Queste entità fungono da punti di ingresso nel knowledge graph. Questo passaggio utilizza un database vettoriale come Milvus per condurre ricerche di similarità testuale.
Mappatura entità-unità di testo: Le unità di testo estratte vengono mappate alle entità corrispondenti, rimuovendo le informazioni testuali originali.
Estrazione entità-relazioni: Il passaggio estrae informazioni specifiche sulle entità e sulle loro relazioni corrispondenti.
Mappatura entità-covariate: Questo passaggio mappa le entità alle loro covariate, che possono includere dati statistici o altri attributi rilevanti.
Mappatura dei report di comunità delle entità: I report di comunità vengono integrati nei risultati di ricerca, incorporando alcune informazioni globali.
Utilizzo della cronologia della conversazione: Se fornita, il sistema utilizza la cronologia della conversazione per comprendere meglio l'intento e il contesto dell'utente.
Generazione della risposta: Infine, il sistema costruisce e risponde alla query dell'utente sulla base dei dati filtrati e ordinati generati nei passaggi precedenti.
RAG di base vs. GraphRAG nella qualità dell'output
Per mostrare l'efficacia di GraphRAG, i suoi creatori confrontano la qualità dell'output di un RAG di base e di GraphRAG nel loro blog di annuncio. Qui citerò un semplice esempio a scopo illustrativo.
Dataset utilizzato
I creatori di GraphRAG hanno utilizzato il dataset Violent Incident Information from News Articles (VIINA) per i loro esperimenti.
Nota: Questo dataset contiene argomenti sensibili. È stato scelto esclusivamente per la sua complessità e per la presenza di opinioni divergenti e informazioni parziali. È un caso di test reale disordinato, abbastanza recente da non essere incluso nell'addestramento del modello di base LLM.
Panoramica dell'esperimento
Sia il RAG di base sia GraphRAG hanno ricevuto la stessa domanda, che richiede di aggregare informazioni attraverso il dataset per comporre una risposta.
D: Quali sono i 5 temi principali nel dataset?
Le risposte sono mostrate nell'immagine sottostante. I risultati del RAG di base erano irrilevanti rispetto ai temi della guerra, poiché la ricerca vettoriale ha recuperato testo non correlato, portando a una valutazione inaccurata. Al contrario, GraphRAG ha fornito una risposta chiara e rilevante, identificando i temi principali e i dettagli di supporto. I risultati erano allineati al dataset, con riferimenti al materiale sorgente.
Figura 4- BaselineRAG vs. GraphRAG nel rispondere a domande complesse di riepilogo
Figura 4: BaselineRAG vs. GraphRAG nel rispondere a domande complesse di riepilogo
Ulteriori esperimenti nell'articolo “From Local to Global: A Graph RAG Approach to Query-Focused Summarization.” dimostrano che GraphRAG migliora significativamente il ragionamento multi-hop e la sintesi di informazioni complesse. La ricerca indica che GraphRAG supera il RAG di base sia in completezza sia in diversità:
Completezza: La misura in cui la risposta copre tutti gli aspetti della domanda.
Diversità: La varietà e ricchezza di prospettive e insight che la risposta fornisce.
Ti consigliamo di leggere l'articolo originale su GraphRAG per maggiori dettagli su questi esperimenti.
Come implementare GraphRAG con il database vettoriale Milvus
GraphRAG potenzia le applicazioni RAG con knowledge graph e si basa anche su un database vettoriale per recuperare entità rilevanti. Questa sezione mostra come implementare GraphRAG, creare un indice GraphRAG e interrogarlo utilizzando il database vettoriale Milvus.
Prerequisiti
Prima di eseguire il codice in questo blog, assicurati di aver installato le seguenti dipendenze:
pip install --upgrade pymilvus
pip install git+https://github.com/zc277584121/graphrag.git
Nota: Abbiamo installato GraphRAG da un repository fork perché la funzionalità di archiviazione Milvus è ancora in attesa di un merge ufficiale al momento della scrittura.
Iniziamo con il flusso di lavoro di indicizzazione.
Preparazione dei dati
Scarica un piccolo file di testo con circa mille righe da Project Gutenberg e usalo per l'indicizzazione di GraphRAG.
Questo dataset riguarda la storia di Leonardo Da Vinci. Usiamo GraphRAG per costruire un indice a grafo di tutte le relazioni correlate a Da Vinci e il database vettoriale Milvus per cercare conoscenze rilevanti per rispondere alle domande.
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()
Inizializzare l'area di lavoro
Ora, usiamo GraphRAG per indicizzare il file di testo. Per inizializzare la tua area di lavoro, eseguiamo prima il comando graphrag.index --init.
python -m graphrag.index --init --root ./graphrag_index
Configurare il file env e le impostazioni
Troverai il file .env nella directory root dell'indice. Per usarlo, aggiungi la tua chiave API OpenAI al file .env.
Note importanti: __
Useremo i modelli OpenAI per questo esempio; assicurati di avere pronta una chiave API.
L'indicizzazione di GraphRAG è costosa perché elabora l'intero corpus di testo con LLM. Eseguire questa demo può costare qualche dollaro. Per risparmiare, considera di troncare il file di testo a una dimensione più piccola.
Eseguire la pipeline di indicizzazione
Il processo di indicizzazione richiederà un po' di tempo. Una volta completato, troverai una nuova cartella in ./graphrag_index/output/<timestamp>/artifacts contenente una serie di file parquet.
python -m graphrag.index --root ./graphrag_index
Eseguire query con il database vettoriale Milvus
Durante la fase di query, usiamo Milvus per archiviare gli embedding delle descrizioni delle entità per la ricerca locale di GraphRAG. Questo metodo combina dati strutturati dal grafo di conoscenza con dati non strutturati dai documenti di input, arricchendo il contesto dell'LLM con informazioni rilevanti sulle entità per risposte più precise.
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
Carica i dati dal processo di indicizzazione
Durante il processo di indicizzazione, verranno generati alcuni file parquet. Li carichiamo in memoria e archiviamo le informazioni sulla descrizione delle entità nel database vettoriale Milvus.
Leggi le entità:
# 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()
Conteggio entità: 651
Figura 5: uno screenshot delle entità
Figura 5: uno screenshot delle entità
Leggi le relazioni
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()
Conteggio relazioni: 290
Figura 6- uno screenshot delle relazioni
Figura 6: uno screenshot delle relazioni
Leggi i report delle community
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()
Record dei report: 45
Figura 7- uno screenshot dei record dei report
Figura 7: uno screenshot dei record dei report
Leggi le unità di testo
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()
Record delle unità di testo: 51
Figura 8- uno screenshot dei record delle unità di testo
Figura 8: uno screenshot dei record delle unità di testo
Crea un motore di ricerca locale
Abbiamo preparato i dati necessari per il motore di ricerca locale. Ora possiamo costruire un'istanza LocalSearch con essi, un LLM e un modello di embedding.
Abbiamo preparato i dati necessari per il motore di ricerca locale. Ora possiamo costruire un'istanza LocalSearch con essi, un LLM e un modello di 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,#todo
entity_text_embeddings=description_embedding_store,
embedding_vectorstore_key=EntityVectorStoreKey.ID, # if the vectorstore uses entity title as ids, set this to 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, # set this to EntityVectorStoreKey.TITLE if the vectorstore uses entity title as ids
"max_tokens": 12_000, # change this based on the token limit you have on your model (if you are using a model with 8k limit, a good setting could be 5000)
}
llm_params = {
"max_tokens": 2_000, # change this based on the token limit you have on your model (if you are using a model with 8k limit, a good setting could be 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="multiple paragraphs", # free form text describing the response type and format, can be anything, e.g. prioritized list, single paragraph, multiple paragraphs, multiple-page report
)
Fai una query.
result = await search_engine.asearch("Tell me about Leonardo Da Vinci")
print(result.response)
# Leonardo da Vinci
Leonardo da Vinci, nato nel 1452 nella città di Vinci vicino a Firenze, è ampiamente celebrato come uno dei geni più versatili del Rinascimento italiano. Il suo nome completo era Leonardo di Ser Piero d'Antonio di Ser Piero di Ser Guido da Vinci, ed era il figlio naturale e primogenito di Ser Piero, un notaio di campagna [Data: Entities (0)]. I contributi di Leonardo spaziarono in vari campi, tra cui arte, scienza, ingegneria e filosofia, guadagnandogli il titolo di Genio più Universale dei tempi cristiani [Data: Entities (8)].
## Vita giovanile e formazione
Il precoce talento di Leonardo fu riconosciuto da suo padre, che portò alcuni dei suoi disegni ad Andrea del Verrocchio, un rinomato artista e scultore. Colpito dal talento di Leonardo, Verrocchio lo accolse nella sua bottega intorno al 1469-1470. Qui Leonardo incontrò altri artisti notevoli, tra cui Botticelli e Lorenzo di Credi [Data: Sources (6, 7)]. Nel 1472, Leonardo fu ammesso alla Gilda dei Pittori Fiorentini, segnando l'inizio della sua carriera professionale [Data: Sources (7)].
## Capolavori artistici
Leonardo è forse meglio conosciuto per i suoi dipinti iconici, come la "Gioconda" e "L'Ultima Cena." La "Gioconda," rinomata per la sua espressione sottile e lo sfondo dettagliato, è conservata al Louvre e rimane una delle opere d'arte più famose al mondo [Data: Relationships (0, 45)]. "L'Ultima Cena," un affresco che raffigura il momento in cui Gesù annunciò che uno dei suoi discepoli lo avrebbe tradito, si trova nel refettorio di Santa Maria delle Grazie a Milano [Data: Sources (2)]. Altre opere significative includono "La Vergine delle Rocce" e il "Trattato della pittura," che iniziò intorno al 1489-1490 [Data: Relationships (7, 12)].
## Contributi scientifici e ingegneristici
Il genio di Leonardo si estese oltre l'arte a varie imprese scientifiche e ingegneristiche. Fece osservazioni significative in anatomia, ottica e idraulica, e i suoi taccuini sono pieni di schizzi e idee che anticiparono molte invenzioni moderne. Per esempio, anticipò la teoria di Copernico sul movimento della terra e la classificazione degli animali di Lamarck [Data: Relationships (38, 39)]. Il suo lavoro sulle leggi della luce e dell'ombra e la sua padronanza del chiaroscuro ebbero un impatto profondo sia sull'arte sia sulla scienza [Data: Sources (45)].
## Mecenatismo e relazioni professionali
La carriera di Leonardo fu significativamente influenzata dai suoi mecenati. Ludovico Sforza, il Duca di Milano, impiegò Leonardo come pittore di corte e artefice generale, commissionandogli varie opere e persino donandogli una vigna nel 1499 [Data: Relationships (9, 19, 84)]. Nei suoi ultimi anni, Leonardo si trasferì in Francia sotto il mecenatismo del re Francesco I, che gli fornì un reddito principesco e lo tenne in grande considerazione [Data: Relationships (114, 37)]. Leonardo trascorse i suoi ultimi anni al Maniero di Cloux vicino ad Amboise, dove riceveva frequenti visite del Re ed era sostenuto dal suo caro amico e assistente, Francesco Melzi [Data: Relationships (28, 122)].
## Eredità e influenza
L'influenza di Leonardo da Vinci si estese ben oltre la sua vita. Fondò una Scuola di pittura a Milano, e le sue tecniche e i suoi insegnamenti furono portati avanti dai suoi studenti e seguaci, come Giovanni Ambrogio da Predis e Francesco Melzi [Data: Relationships (6, 15, 28)]. Le sue opere continuano a essere celebrate e studiate, consolidando la sua eredità come uno dei più grandi maestri del Rinascimento. La capacità di Leonardo di fondere arte e scienza ha lasciato un segno indelebile in entrambi i campi, ispirando innumerevoli generazioni di artisti e scienziati [Data: Entities (148, 86); Relationships (27, 12)].
In sintesi, i contributi senza pari di Leonardo da Vinci all'arte, alla scienza e all'ingegneria, combinati con il suo pensiero innovativo e la sua profonda influenza sui suoi contemporanei e sulle generazioni future, lo rendono una figura imponente nella storia delle realizzazioni umane. La sua eredità continua a ispirare ammirazione e studio, sottolineando la rilevanza senza tempo del suo genio.
I risultati di GraphRAG sono specifici, con le fonti di dati citate chiaramente contrassegnate.
Generazione di domande
GraphRAG può anche generare domande basate su query storiche, il che è utile per creare domande consigliate in un dialogo con un chatbot. Questo metodo combina dati strutturati dal knowledge graph con dati non strutturati dai documenti di input per produrre domande candidate relative a entità specifiche.
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 domande basate sulla cronologia.
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?"]
Puoi rimuovere la radice dell'indice se vuoi eliminare l'indice per risparmiare spazio.
# import shutil
#
# shutil.rmtree(index_root)
Riepilogo
In questo blog abbiamo esplorato GraphRAG, un metodo innovativo che potenzia la tecnologia RAG integrando i knowledge graph. GraphRAG è ideale per affrontare attività complesse come il ragionamento multi-hop e rispondere a domande complete che richiedono di collegare elementi di informazione disparati.
In combinazione con il database vettoriale Milvus, GraphRAG può navigare relazioni semantiche complesse all'interno di grandi dataset, fornendo risultati più accurati e approfonditi. Questa potente combinazione rende GraphRAG una risorsa inestimabile per varie applicazioni pratiche di GenAI, offrendo una soluzione robusta per comprendere ed elaborare informazioni complesse.
Ulteriori risorse
Il paper su GraphRAG: From Local to Global: A Graph RAG Approach to Query-Focused Summarization
GraphRAG GitHub: https://github.com/microsoft/graphrag
Altre tecniche di potenziamento di RAG:
Continua a leggere
Why and How to Migrate from Self-Hosted Milvus to Zilliz Cloud
A simple, step-by-step guide to migrating from Milvus to Zilliz Cloud. Learn both endpoint and backup methods for a smooth, scalable vector database migration.
Will Amazon S3 Vectors Kill Vector Databases—or Save Them?
AWS S3 Vectors aims for 90% cost savings for vector storage. But will it kill vectordbs like Milvus? A deep dive into costs, limits, and the future of tiered storage.
How to Build an Enterprise-Ready RAG Pipeline on AWS with Bedrock, Zilliz Cloud, and LangChain
Build production-ready enterprise RAG with AWS Bedrock, Nova models, Zilliz Cloud, and LangChain. Complete tutorial with deployable code.