Setting Up and Operating GraphRAG with Neo4j

The GraphRAG Python package deal by Neo4j presents a complete answer for constructing end-to-end workflows, from remodeling unstructured knowledge right into a information graph to enabling information graph retrieval and implementing full GraphRAG pipelines. Whether or not you’re creating information assistants, search APIs, chatbots, or report turbines in Python, this package deal simplifies the mixing of data graphs to reinforce the relevance, accuracy, and explainability of retrieval-augmented era (RAG).

On this information, we’ll display the way to get began with the GraphRAG Python package deal, construct a GraphRAG pipeline from scratch, and discover varied information graph retrieval strategies to customise the conduct of your GenAI software.

GraphRAG: Enhancing GenAI with Information Graphs

By combining information graphs with RAG, GraphRAG addresses widespread challenges of massive language fashions (LLMs), corresponding to hallucinations, whereas enriching responses with domain-specific context for higher high quality and precision than conventional RAG strategies. Information graphs present important contextual knowledge, enabling LLMs to ship dependable solutions and act as trusted brokers in complicated duties. In contrast to standard RAG options that target fragmented textual knowledge, GraphRAG integrates each structured and semi-structured knowledge into the retrieval course of.

With the GraphRAG Python package deal, you may create information graphs and implement superior retrieval strategies, together with graph traversals, question era through text-to-Cypher, vector searches, and full-text searches. The package deal additionally contains instruments for constructing full RAG pipelines, enabling seamless integration of GraphRAG with Neo4j into GenAI workflows and functions.

Key Parts of the GraphRAG Information Graph Building Pipeline

The GraphRAG information graph (KG) development pipeline consists of a number of elements, every important in remodeling uncooked textual content into structured knowledge for enhanced Retrieval-Augmented Technology (RAG)- GraphRAG with Neo4j. These elements work collectively to allow superior retrieval strategies like graph-based searches and context-aware responses. Under are the core elements:

• Doc Parser: Extracts textual content from varied doc codecs (e.g., PDFs).
• Doc Chunker: Splits the textual content into smaller items that match inside the LLM’s token restrict.
• Chunk Embedder (Optionally available): Computes vector embeddings for every chunk, enabling semantic matching.
• Schema Builder: Defines the construction of the KG, grounding entity extraction and making certain consistency.
• LexicalGraphBuilder (Optionally available): Builds a lexical graph connecting paperwork and chunks.
• Entity and Relation Extractor: Identifies entities (e.g., individuals, dates) and their relationships.
• Information Graph Author: Saves the entities and relations to the graph database for retrieval.
• Entity Resolver: Merges duplicate or related entities right into a single node to keep up graph integrity.

Entity Resolver: Merges duplicate or related entities right into a single node to keep up graph integrity.

These elements work collectively to create a dynamic information graph that powers GraphRAG, enabling extra correct and context-aware responses from LLMs.

Set Up a Neo4j Database

To start the RAG workflow, step one is to arrange a database for retrieval. Neo4j AuraDB supplies a simple technique to launch a free Graph Database. Relying on the necessities, one can go for AuraDB Free for fundamental use or strive AuraDB Skilled (Professional), which presents elevated reminiscence and higher efficiency for ingestion and retrieval duties. Whereas the Professional model is good for optimum outcomes because of its superior options, for this challenge, I’ll make the most of Neo4j AuraDB’s free Graph Database.It’s a totally managed cloud service that provides a scalable and high-performance graph database answer. With its free tier, customers can simply construct and discover graph-based functions, leveraging highly effective relationships between knowledge factors for insights and evaluation.

Upon logging into Neo4j AuraDB, you may create a free occasion. As soon as the occasion is ready up, you’ll obtain or can obtain the mandatory credentials, together with the username, Neo4j URL, and password, to connect with your database.

Set up the Required Libraries

We are going to set up a number of libraries utilizing pip, together with Neo4j’s Python Driver and OpenAI to create GraphRAG with Neo4j & Python. That is an important step for establishing our surroundings.

!pip set up fsspec openai numpy torch neo4j-graphrag

Set Up Connection Particulars for Neo4j

NEO4J_URI = ""
username = ""
password = ""

On this part, now we have to outline the connection particulars for Neo4j. Exchange the placeholders along with your precise Neo4j database credentials:

• NEO4J_URI: URI to your Neo4j occasion (e.g., bolt://localhost:7687).
• username and password: Your Neo4j authentication credentials.

Set OpenAI API Key

import os
os.environ['OPENAI_API_KEY'] = ''

Right here, we’re loading  OpenAI API key utilizing os.environ. This permits us to make use of OpenAI’s fashions for entity extraction in your information graph.

1. Constructing and Defining the Information Graph Pipeline

To facilitate our analysis on the greenhouse impact to point out GraphRAG with Neo4j & Python, we are going to rework analysis papers right into a structured information graph and retailer it in a Neo4j database. Utilizing a number of PDF paperwork targeted on greenhouse impact research; we’ll set up the domain-specific knowledge these paperwork include right into a graph that enhances AI-driven functions. This method permits for higher structuring and retrieval of complicated scientific data.

The information graph will embrace key node varieties:

• Doc: Captures metadata associated to the doc sources.
• Chunk: Represents textual content segments from the paperwork, embedded with vector representations for environment friendly retrieval.
• Entity: Extracted entities from the textual content chunks, offering structured context and connections.

To automate the creation of this information graph, we outline a SimpleKGPipeline class. This class permits seamless information graph development by requiring a couple of important inputs:

• A Neo4j driver to connect with the Neo4j database.
• An LLM (Language Mannequin) for entity extraction.
• An embedding mannequin to transform textual content into vectors, enabling similarity searches.

By combining the doc transformation with an automatic pipeline, we are able to construct a complete information graph that effectively organizes and retrieves insights in regards to the greenhouse impact.

Neo4j Driver Initialization

import neo4j
from neo4j_graphrag.llm import OpenAILLM
from neo4j_graphrag.embeddings.openai import OpenAIEmbeddings

driver = neo4j.GraphDatabase.driver(NEO4J_URI, auth=(username, password))

Right here, we initialize the Neo4j database driver utilizing the NEO4J_URI, username, and password set earlier. We will additionally import elements wanted for LLM-based entity extraction (OpenAILLM) and embedding (OpenAIEmbeddings).

Initialize LLM and Embedding Mannequin

llm = OpenAILLM(
    model_name="gpt-4o-mini",
    model_params={"response_format": {"kind": "json_object"}, "temperature": 0},
)

embedder = OpenAIEmbeddings()

We now have initialized the LLM (OpenAILLM) for entity extraction and set parameters just like the mannequin identify (GPT-4o-mini) and response format. The embedder is initialized with OpenAIEmbeddings, which will probably be used to transform textual content chunks into vectors for similarity search.

Setting Node Labels

Let’s outline completely different classes of nodes primarily based on our use case:

basic_node_labels = ["Object", "Entity", "Group", "Person", "Organization", "Place"]
academic_node_labels = ["ArticleOrPaper", "PublicationOrJournal"]
climate_change_node_labels = ["GreenhouseGas", "TemperatureRise", "ClimateModel", "CarbonFootprint", "EnergySource"]

node_labels = basic_node_labels + academic_node_labels + climate_change_node_labels

Right here, we’ve grouped our node labels into:

• Primary node labels: Generic entity varieties corresponding to “Individual”, “Group”, and so forth.
• Tutorial node labels: Associated to tutorial publications like articles or journals.
• Local weather change node labels: Particular to local weather change-related entities.

These labels will assist categorize entities inside your information graph.

Defining Relationship Varieties

rel_types = ["AFFECTS", "CAUSES", "ASSOCIATED_WITH", "DESCRIBES", "PREDICTS", "IMPACTS"]

We now have outlined potential relationships between nodes within the graph. These relationships describe how entities work together or are related.

Creating the Immediate Template

prompt_template=""'
You're a local weather researcher tasked with extracting data from analysis papers and structuring it in a property graph.

Extract the entities (nodes) and specify their kind from the next textual content.
Additionally extract the relationships between these nodes.

Return the outcome as JSON utilizing the next format:
{{"nodes": [ {{"id": "0", "label": "entity type", "properties": {{"name": "entity name"}} }} ],
  "relationships": [{{"type": "RELATIONSHIP_TYPE", "start_node_id": "0", "end_node_id": "1", "properties": {{"details": "Relationship details"}} }}] }}

Enter textual content:

{textual content}
'''

Right here, we outlined a immediate template for the LLM. The mannequin will probably be given a textual content (analysis paper), and it must extract:

• Entities (nodes): These are recognized by kind (e.g., Individual, Group) and their properties (e.g., identify).
• Relationships: The LLM will establish how the entities are associated (e.g., “CAUSES”, “ASSOCIATED_WITH”).

Create the Information Graph Pipeline

from neo4j_graphrag.experimental.elements.text_splitters.fixed_size_splitter import FixedSizeSplitter
from neo4j_graphrag.experimental.pipeline.kg_builder import SimpleKGPipeline

Right here, we’re importing the mandatory lessons:

• FixedSizeSplitter: It will assist cut up massive textual content (from PDFs) into smaller chunks.
• SimpleKGPipeline: That is the primary class for constructing your information graph.

Constructing the Information Graph Pipeline

kg_builder_pdf = SimpleKGPipeline(
    llm=llm,
    driver=driver,
    text_splitter=FixedSizeSplitter(chunk_size=500, chunk_overlap=100),
    embedder=embedder,
    entities=node_labels,
    relations=rel_types,
    prompt_template=prompt_template,
    from_pdf=True
)

• llm: Language mannequin used for entity extraction (you already initialized it with OpenAI’s LLM).
• driver: The Neo4j driver that connects to your Neo4j occasion.
• text_splitter: You employ FixedSizeSplitter to interrupt down massive textual content from the PDFs into chunks of 500 tokens with an overlap of 100 tokens.
• embedder: Embedding mannequin used to transform the textual content chunks into vector embeddings.
• entities: Specifies the node labels that outline the entities in your information graph.
• relations: Specifies the connection varieties that join the nodes within the graph.
• prompt_template: The template for instructing the LLM to extract nodes and relationships.
• from_pdf=True: Tells the pipeline to extract knowledge from PDF recordsdata.

Processing PDFs

On this, we’re utilizing three completely different  analysis papers on Greenhouse:

pdf_file_paths = ['/home/janvi/Downloads/ToxipediaGreenhouseEffectArchive.pdf',
                  '/home/janvi/Downloads/3.1.pdf',
                  '/home/janvi/Downloads/Shell_Climate_1988.pdf']

for path in pdf_file_paths:
    print(f"Processing: {path}")
    pdf_result = await kg_builder_pdf.run_async(file_path=path)
    print(f"Consequence: {pdf_result}")

This loop processes the three PDF recordsdata and feeds them into the SimpleKGPipeline. It makes use of run_async to course of the paperwork asynchronously and prints the outcome for every doc.

As soon as full, you may discover the ensuing information graph. The Unified Console supplies an incredible interface for this.

Go to the Question tab and enter the under question to see a pattern of the graph.

MATCH p=()-->() RETURN p LIMIT 100;

You possibly can see how the Doc, Chunk, and __Entity__ nodes are all related collectively.

To see the “lexical” portion of the graph containing Doc and Chunk nodes, run the next.

MATCH p=(:Chunk)--(:!__Entity__) RETURN p;

Observe that these are disconnected elements, one for every doc we ingested. You can too see the embeddings which were added to all chunks.

To take a look at simply the area graph of __Entity__ nodes, you may run the next:

MATCH p=(:!Chunk)-->(:!Chunk) RETURN p;

You will note how completely different ideas have been extracted and the way they join to at least one one other. This area graph connects data between the paperwork.

2. Retrieving Knowledge From Your Information Graph

As soon as the information graph for greenhouse impact analysis is constructed, the following step includes retrieving significant data to help evaluation. The GraphRAG Python package deal supplies versatile retrieval mechanisms tailor-made to your wants. These embrace:

• Vector Retriever: Conducts similarity searches utilizing vector embeddings for environment friendly knowledge retrieval.
• Vector Cypher Retriever: Combines vector search with Cypher queries, Neo4j’s graph question language, enabling graph traversal to incorporate associated nodes and relationships within the retrieval.
• Hybrid Retriever: Merges vector and full-text seek for complete knowledge retrieval.
• Hybrid Cypher Retriever: Combines hybrid search with Cypher queries for superior graph traversal.
• Text2Cypher: Converts pure language queries into Cypher queries, enabling customers to retrieve knowledge straight from Neo4j with out handbook question writing.
• Weaviate & Pinecone Neo4j Retriever: Integrates vector searches from exterior techniques like Weaviate or Pinecone with Neo4j nodes utilizing exterior ID properties.
• Customized Retriever: Gives flexibility for implementing tailor-made retrieval strategies for particular wants.

These retrieval mechanisms empower the implementation of various retrieval patterns, enhancing the relevance and accuracy of retrieval-augmented era (RAG) pipelines.

Vector Retriever and Information Graph Retrieval

For our greenhouse impact analysis information graph, we make the most of the Vector Retriever, which makes use of Approximate Nearest Neighbor (ANN) vector search. This retriever retrieves knowledge by performing similarity searches on embeddings related to textual content chunks saved within the graph.

Setting Up a Vector Index

To allow vector-based retrieval, we create a Vector Index in Neo4j. This index operates on the textual content chunks within the graph, permitting the Vector Retriever to drag again related insights with excessive precision.

By combining Neo4j’s vector search capabilities and these retrieval strategies, we are able to question the information graph to extract precious details about the causes, results, and options associated to the greenhouse impact.

from neo4j_graphrag.indexes import create_vector_index

create_vector_index(driver, identify="text_embeddings", label="Chunk",
                    embedding_property="embedding", dimensions=1536, similarity_fn="cosine")

create_vector_index: This perform creates a vector index on the Chunk label in Neo4j. The embeddings (generated from the PDF textual content) will probably be saved within the embedding property of every Chunk node. The index is predicated on cosine similarity, and the embeddings have a dimension of 1536, which is commonplace for OpenAI’s embeddings.

Utilizing the VectorRetriever

from neo4j_graphrag.retrievers import VectorRetriever

vector_retriever = VectorRetriever(
    driver,
    index_name="text_embeddings",
    embedder=embedder,
    return_properties=["text"],
)

VectorRetriever: This part queries the Chunk nodes utilizing vector search, which permits us to search out probably the most related chunks primarily based on the enter question. The return_properties parameter ensures that the search outcomes will return the textual content of the chunk.

Looking for Info within the Information Graph

import json

vector_res = vector_retriever.get_search_results(
    query_text="What are the primary greenhouse gases contributing to the Greenhouse Impact and their impacts as mentioned within the paperwork?",
    top_k=3
)

for i in vector_res.information:
    print("====n" + json.dumps(i.knowledge(), indent=4))

• get_search_results: This perform performs a vector search with the enter question (on this case, asking about greenhouse gases and their impacts).
• top_k=3: We’re limiting the variety of outcomes to the highest 3 most related chunks.
• The outcomes are printed in a properly formatted JSON construction, which incorporates the related textual content and metadata of the retrieved chunks.

Utilizing the VectorCypherRetriever for Graph Traversal

The VectorCypherRetriever permits for a complicated methodology of data graph retrieval by combining vector search with Cypher queries. This permits us to traverse the graph primarily based on semantic similarities discovered within the textual content, exploring associated entities and their relationships.

Organising the VectorCypherRetriever

from neo4j_graphrag.retrievers import VectorCypherRetriever

vc_retriever = VectorCypherRetriever(
    driver,
    index_name="text_embeddings",
    embedder=embedder,
    retrieval_query="""
// 1) Exit 2-3 hops within the entity graph and get relationships
WITH node AS chunk
MATCH (chunk)<-[:FROM_CHUNK]-()-[relList:!FROM_CHUNK]-{1,2}()
UNWIND relList AS rel

// 2) Gather relationships and textual content chunks
WITH accumulate(DISTINCT chunk) AS chunks, 
  accumulate(DISTINCT rel) AS rels

// 3) Format and return context
RETURN '=== textual content ===n' + apoc.textual content.be part of([c in chunks | c.text], 'n---n') + 'nn=== kg_rels ===n' +
  apoc.textual content.be part of([r in rels | startNode(r).name + ' - ' + type(r) + '(' + coalesce(r.details, '') + ')' +  ' -> ' + endNode(r).name ], 'n---n') AS data
"""
)

• retrieval_query: This Cypher question is used to outline the logic of traversing the graph. Right here, you traverse 2-3 hops away from every chunk and seize the relationships between the chunks.
• Textual content and Relationship Formatting: The outcomes are formatted to return the chunk textual content first, adopted by the relationships encountered through the traversal.

Operating a Question for Related Info

vc_res = vc_retriever.get_search_results(
    query_text="What are the causes and penalties of the Greenhouse Impact as mentioned within the supplied paperwork?", 
    top_k=3
)

• get_search_results: This methodology performs a vector search primarily based on the enter question. It should return the highest 3 most related chunks and their related relationships within the information graph.

Extracting and Printing Outcomes

kg_rel_pos = vc_res.information[0]['info'].discover('nn=== kg_rels ===n')

# Print the outcomes, separating the textual content chunk context and the KG context
print("# Textual content Chunk Context:")
print(vc_res.information[0]['info'][:kg_rel_pos])

print("# KG Context From Relationships:")
print(vc_res.information[0]['info'][kg_rel_pos:])

• kg_rel_pos: This locates the place the relationships begin within the response.
• The outcomes are then printed, separating the textual context from the relationships discovered within the information graph.

3. Establishing a GraphRAG Pipeline

To additional improve the retrieval-augmented era (RAG) course of for our greenhouse impact analysis, we now combine each the VectorRetriever and VectorCypherRetriever right into a GraphRAG pipeline. This integration permits us to retrieve related knowledge and use that context to generate responses which can be strictly primarily based on the information graph, making certain accuracy and reliability within the generated solutions.

Instantiating and Operating GraphRAG

The GraphRAG Python package deal simplifies the method of instantiating and operating RAG pipelines. You possibly can simply create a GraphRAG pipeline by using the GraphRAG class. At its core, the category requires two important elements:

1. LLM (Language Mannequin): That is answerable for producing pure language responses primarily based on the retrieved context.
2. Retriever: That is used to fetch related data from the information graph (e.g., utilizing VectorRetriever or VectorCypherRetriever).

Organising the GraphRAG Pipeline

from neo4j_graphrag.llm import OpenAILLM as LLM
from neo4j_graphrag.era import RagTemplate
from neo4j_graphrag.era.graphrag import GraphRAG

llm = LLM(model_name="gpt-4o", model_params={"temperature": 0.0})

rag_template = RagTemplate(template=""'Reply the Query utilizing the next Context. Solely reply with data talked about within the Context. Don't inject any speculative data not talked about. 

# Query:
{query_text}

# Context:
{context}

# Reply:
''', expected_inputs=['query_text', 'context'])

• RagTemplate: The template ensures that the LLM solely responds primarily based on the supplied context, avoiding any speculative solutions.
• GraphRAG: The GraphRAG class makes use of a language mannequin and a retriever to drag in context to reply the question. It’s initialized with each a vector_retriever and vc_retriever.

Creating the GraphRAG Pipelines

v_rag  = GraphRAG(llm=llm, retriever=vector_retriever, prompt_template=rag_template)
vc_rag = GraphRAG(llm=llm, retriever=vc_retriever, prompt_template=rag_template)

• v_rag: Makes use of the VectorRetriever to seek for related textual content chunks and reply questions.
• vc_rag: Makes use of the VectorCypherRetriever to each seek for related textual content and traverse relationships within the information graph.

Now we will probably be executing queries utilizing each the VectorRetriever and VectorCypherRetriever by way of the GraphRAG pipeline to retrieve context and generate solutions from the information graph. Right here’s a breakdown of the code:

Question 1: “Record the causes, results, and options for the Greenhouse Impact.”This question checks the solutions supplied by each the vector-based retrieval and vector + Cypher graph traversal strategies:

q = "Record the causes, results, and options for the Greenhouse Impact."
print(f"Vector Response: n{v_rag.search(q, retriever_config={'top_k':5}).reply}")
print("n===========================n")
print(f"Vector + Cypher Response: n{vc_rag.search(q, retriever_config={'top_k':5}).reply}")

Question 2: “Clarify the Greenhouse Impact intimately. Embrace its pure course of, human-induced causes, international warming impacts, and local weather change results as mentioned within the supplied paperwork.”Right here, we’re asking for a extra detailed rationalization. The return_context=True flag is used to return the context together with the reply:

q = "Clarify the Greenhouse Impact intimately. Embrace its pure course of, human-induced causes, impacts on international warming, and its results on local weather change as mentioned within the supplied paperwork."
v_rag_result = v_rag.search(q, retriever_config={'top_k': 5}, return_context=True)
vc_rag_result = vc_rag.search(q, retriever_config={'top_k': 5}, return_context=True)

print(f"Vector Response: n{v_rag_result.reply}")
print("n===========================n")
print(f"Vector + Cypher Response: n{vc_rag_result.reply}")

Exploring Retrieved Content material: After getting the context outcomes, we’re printing and parsing the contents from the vector and Cypher retrievers:

for i in v_rag_result.retriever_result.objects: 
    print(json.dumps(eval(i.content material), indent=1))

For the vc_rag_result, we’re splitting the content material and filtering for any textual content containing the key phrase “deal with”:

vc_ls = vc_rag_result.retriever_result.objects[0].content material.cut up('n---n')
for i in vc_ls:
    if "deal with" in i: 
        print(i)

Question 3: “Are you able to summarize the Greenhouse Impact?”Lastly, we’re summarizing the knowledge requested by the consumer in listing format. Just like earlier queries, we’re retrieving the outcomes and printing the solutions:

q = "Are you able to summarize the Greenhouse Impact? Embrace its pure course of, greenhouse gases concerned, impacts on the setting and human well being, and challenges in addressing local weather change. Present in listing format with particulars for every merchandise."
print(f"Vector Response: n{v_rag.search(q, retriever_config={'top_k': 5}).reply}")
print("n===========================n")
print(f"Vector + Cypher Response: n{vc_rag.search(q, retriever_config={'top_k': 5}).reply}")

Conclusion

This text explored how the GraphRAG Python package deal (GraphRAG with Neo4j) can successfully improve the retrieval-augmented era (RAG) course of by integrating information graphs with massive language fashions (LLMs). We demonstrated the way to create a information graph from analysis paperwork associated to the Greenhouse Impact and the way to retailer and handle this graph utilizing Neo4j(GraphRAG with Neo4j). By defining the information graph pipeline and leveraging varied retrieval strategies, corresponding to VectorRetriever and VectorCypherRetriever, we confirmed the way to retrieve related data from the graph to generate correct and contextually related responses.

Combining information graphs with RAG helps tackle widespread points corresponding to hallucinations and supplies domain-specific context that improves the standard of responses. Moreover, by incorporating a number of retrieval strategies, we enhanced the accuracy and relevance of the generated content material, making it extra dependable and helpful for answering complicated questions associated to the greenhouse impact.

Total, GraphRAG with Neo4j presents a strong toolset for constructing knowledge-powered functions that require each correct knowledge retrieval and pure language era. Incorporating Neo4j’s graph capabilities ensures that responses are contextually grounded and knowledgeable by structured and semi-structured knowledge, providing a extra sturdy answer than conventional RAG strategies.

Regularly Requested Questions

Hello, I’m Janvi, a passionate knowledge science fanatic at present working at Analytics Vidhya. My journey into the world of information started with a deep curiosity about how we are able to extract significant insights from complicated datasets.