Real-Time GraphRAG with LangChain, Neo4j, and GPT

Introduction to GraphRAG

GraphRAG combines graph databases, information extraction, retrieval, and large language models to organize unstructured data into queryable knowledge structures. Instead of relying only on vector similarity, GraphRAG captures entities, relationships, communities, and paths that can provide stronger grounding for complex analytical questions.

In a production architecture, the graph layer is not just a storage choice. It becomes the semantic backbone for entity resolution, relationship traversal, provenance tracking, and controlled retrieval before the final response is generated by the language model.

Reference Implementation: Basic GraphRAG Structure

The following simplified example shows the minimum shape of a GraphRAG abstraction: nodes, edges, relationships, and a query interface.

# Simulating a basic GraphRAG structure
class GraphRAG:
    def __init__(self):
        self.graph = {}
        self.llm = None  # Placeholder for language model

    def add_node(self, node, attributes):
        self.graph[node] = attributes

    def add_edge(self, node1, node2, relationship):
        if node1 not in self.graph:
            self.graph[node1] = {}
        if node2 not in self.graph:
            self.graph[node2] = {}
        self.graph[node1][node2] = relationship

    def query(self, question):
        # Simulate query processing
        return f"Processed query: {question}"

# Usage example
graph_rag = GraphRAG()
graph_rag.add_node("Person", {"name": "John"})
graph_rag.add_node("City", {"name": "New York"})
graph_rag.add_edge("Person", "City", "lives_in")

result = graph_rag.query("Where does John live?")
print(result)

RAGraphX v1 Architecture Components

RAGraphX v1 integrates four core layers to support document ingestion, graph construction, retrieval, and response generation:

1. LangChain: Orchestration layer for prompts, chains, model calls, and retrieval workflows.
2. Neo4j: Graph database used to persist entities, relationships, and queryable knowledge structures.
3. OpenAI GPT: Language model layer used for extraction, query interpretation, and response synthesis.
4. Streamlit: Lightweight application interface for uploading documents and submitting natural language queries.

These components work together to transform unstructured documents into graph-backed knowledge that can be queried through both Cypher and natural language.

Reference Implementation: Application Components

The following example outlines the main application services and connection points.

# Simulating RAGraphX v1 components
from langchain import LLMChain
from neo4j import GraphDatabase
import openai
import streamlit as st

# LangChain setup
llm = LLMChain(prompt="Your prompt here")

# Neo4j setup
driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password"))

# OpenAI GPT setup
openai.api_key = "your-api-key"

# Streamlit app
def main():
    st.title("RAGraphX v1")
    
    # File uploader
    uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
    
    if uploaded_file is not None:
        # Process the file (placeholder)
        st.write("Processing file...")

    # Query input
    query = st.text_input("Enter your query")
    if query:
        # Process query (placeholder)
        st.write(f"Processing query: {query}")

if __name__ == "__main__":
    main()

Document Processing Workflow

The document processing workflow in RAGraphX v1 involves several steps:

1. PDF Upload: Users upload PDF documents through the Streamlit interface.
2. Text Extraction: The application extracts text content from the PDFs.
3. Entity Recognition: Using LangChain and GPT models, the system identifies key entities and relationships in the text.
4. Graph Creation: Identified entities and relationships are stored in the Neo4j graph database.

This process transforms unstructured document data into a structured, queryable graph representation.

Reference Implementation: Document Processing Workflow

The following example shows a simplified ingestion flow from PDF extraction to graph persistence.

import PyPDF2
from langchain import OpenAI, LLMChain
from neo4j import GraphDatabase

def process_document(file):
    # Extract text from PDF
    pdf_reader = PyPDF2.PdfReader(file)
    text = ""
    for page in pdf_reader.pages:
        text += page.extract_text()

    # Entity recognition (simplified)
    llm = OpenAI(temperature=0)
    entities = llm("Extract entities from: " + text[:1000])  # Using first 1000 chars as example

    # Store in Neo4j (simplified)
    driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password"))
    with driver.session() as session:
        for entity in entities.split(','):
            session.run("CREATE (e:Entity {name: $name})", name=entity.strip())

    return "Document processed and entities stored in graph"

# Usage in Streamlit app
if uploaded_file is not None:
    result = process_document(uploaded_file)
    st.write(result)

Natural Language Query Processing

RAGraphX v1 allows users to interact with the stored knowledge using natural language queries. The query processing involves:

1. Query Input: Users enter their questions in natural language.
2. Query Translation: The system uses GPT models to translate the natural language query into a Cypher query, which is the query language for Neo4j.
3. Graph Querying: The generated Cypher query is executed on the Neo4j database.
4. Response Generation: The retrieved information is processed and formatted into a human-readable response.

This approach provides a natural language interface over complex graph structures while keeping the retrieval path auditable through generated Cypher queries.

Reference Implementation: Natural Language Query Processing

The following example demonstrates a simplified query translation and response synthesis flow.

from openai import OpenAI
from neo4j import GraphDatabase

def process_query(query):
    # Translate query to Cypher
    client = OpenAI(api_key="your-api-key")
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "Translate the following query to Cypher:"},
            {"role": "user", "content": query}
        ]
    )
    cypher_query = response.choices[0].message.content

    # Execute Cypher query
    driver = GraphDatabase.driver("neo4j://localhost:7687", auth=("neo4j", "password"))
    with driver.session() as session:
        result = session.run(cypher_query).data()

    # Generate response (simplified)
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": "Summarize this data:"},
            {"role": "user", "content": str(result)}
        ]
    )
    return response.choices[0].message.content

# Usage in Streamlit app
query = st.text_input("Enter your query")
if query:
    result = process_query(query)
    st.write(result)

Use Case: Scientific Literature Review

Consider a researcher using RAGraphX v1 to analyze a large corpus of scientific papers. They upload multiple PDFs of research articles, and the system extracts key information such as authors, institutions, methodologies, and findings. This information is stored in the Neo4j graph, creating a network of interconnected research data.

The researcher can then query this knowledge graph with natural language questions like “What are the recent advancements in CRISPR gene editing?” The system would process this query, search the graph for relevant information, and provide a complete summary of recent CRISPR developments found in the uploaded papers.

Reference Implementation: Scientific Literature Review

The following example shows a simplified domain-specific graph construction flow.

# Simulating scientific literature review with RAGraphX v1

def process_scientific_papers(papers):
    graph = {}
    for paper in papers:
        # Extract info (simplified)
        info = extract_paper_info(paper)
        # Add to graph
        add_to_graph(graph, info)
    return graph

def extract_paper_info(paper):
    # Simulate extraction using LLM
    llm_response = llm(f"Extract title, authors, and key findings from: {paper[:500]}")
    # Parse LLM response (simplified)
    return parse_llm_response(llm_response)

def add_to_graph(graph, info):
    # Add nodes and edges to graph (simplified)
    graph[info['title']] = {
        'authors': info['authors'],
        'findings': info['findings']
    }

def query_graph(graph, query):
    # Simulate natural language query processing
    relevant_papers = [title for title, data in graph.items() if query.lower() in data['findings'].lower()]
    return f"Relevant papers for '{query}': {', '.join(relevant_papers)}"

# Example usage
papers = ["Paper 1 content...", "Paper 2 content...", "Paper 3 content..."]
knowledge_graph = process_scientific_papers(papers)
result = query_graph(knowledge_graph, "CRISPR gene editing")
print(result)

Use Case: Product Recommendation System

Imagine an e-commerce platform implementing RAGraphX v1 to create a smart product recommendation system. The application processes product descriptions, customer reviews, and purchase histories, creating a complex graph of product relationships and customer preferences.

When a customer asks, “What hiking boots are best for rainy conditions?”, the system navigates the graph to find boots with high waterproof ratings, positive reviews for wet conditions, and frequently co-purchased with rain gear. It then generates a personalized recommendation based on the customer’s past purchases and preferences.

Reference Implementation: Product Recommendation System

The following example illustrates how graph-backed product attributes and customer preferences can be used for recommendation logic.

class ProductRecommendationSystem:
    def __init__(self):
        self.product_graph = {}
        self.customer_preferences = {}

    def add_product(self, product_id, attributes):
        self.product_graph[product_id] = attributes

    def add_customer_preference(self, customer_id, preferences):
        self.customer_preferences[customer_id] = preferences

    def recommend_products(self, query, customer_id):
        # Simulate natural language processing
        keywords = self.extract_keywords(query)
        
        # Find matching products
        matching_products = self.find_matching_products(keywords)
        
        # Personalize recommendations
        personalized_recommendations = self.personalize_recommendations(matching_products, customer_id)
        
        return personalized_recommendations

    def extract_keywords(self, query):
        # Simplified keyword extraction
        return [word.lower() for word in query.split() if len(word) > 3]

    def find_matching_products(self, keywords):
        matching_products = []
        for product_id, attributes in self.product_graph.items():
            if any(keyword in str(attributes).lower() for keyword in keywords):
                matching_products.append(product_id)
        return matching_products

    def personalize_recommendations(self, products, customer_id):
        if customer_id in self.customer_preferences:
            preferences = self.customer_preferences[customer_id]
            return sorted(products, key=lambda p: self.calculate_relevance(p, preferences), reverse=True)
        return products

    def calculate_relevance(self, product_id, preferences):
        # Simplified relevance calculation
        return sum(1 for pref in preferences if pref in str(self.product_graph[product_id]).lower())

# Example usage
recommender = ProductRecommendationSystem()
recommender.add_product("boot1", {"type": "hiking", "features": ["waterproof", "durable"]})
recommender.add_product("boot2", {"type": "hiking", "features": ["lightweight", "breathable"]})
recommender.add_customer_preference("customer1", ["waterproof", "hiking"])

recommendations = recommender.recommend_products("hiking boots for rainy conditions", "customer1")
print(f"Recommended products: {recommendations}")

Production Challenges and Future Enhancements

While RAGraphX v1 represents a significant advancement in knowledge extraction and querying, several challenges and areas for future development remain:

1. Scalability: Handling extremely large datasets and complex graphs smartly.
2. Query Accuracy: Improving the accuracy of natural language to Cypher query translation.
3. Knowledge Integration: Seamlessly integrating information from diverse sources and formats.
4. Real-time Updates: Enabling dynamic updates to the knowledge graph as new information becomes available.
5. Ethical Considerations: Addressing privacy concerns and ensuring responsible use of extracted knowledge.

Future versions of RAGraphX should incorporate graph algorithms, stronger natural language understanding, controlled Cypher generation, evaluation pipelines, and improved visualization for explainability.

Reference Implementation: Scaling and Caching Pattern

The following example shows a simplified caching and batch-processing pattern for higher-throughput query handling.

import time
from concurrent.futures import ThreadPoolExecutor

class AdvancedGraphRAG:
    def __init__(self):
        self.graph = {}
        self.query_cache = {}

    def add_node(self, node, attributes):
        self.graph[node] = attributes

    def query(self, natural_language_query):
        # Check cache first
        if natural_language_query in self.query_cache:
            return self.query_cache[natural_language_query]

        # Simulate complex query processing
        time.sleep(2)  # Simulating processing time
        result = f"Processed: {natural_language_query}"

        # Cache the result
        self.query_cache[natural_language_query] = result
        return result

    def batch_process(self, queries):
        with ThreadPoolExecutor(max_workers=5) as executor:
            return list(executor.map(self.query, queries))

# Example usage
graph_rag = AdvancedGraphRAG()
graph_rag.add_node("Entity1", {"attribute": "value"})

# Single query
print(graph_rag.query("What is Entity1?"))

# Batch processing
batch_queries = ["Query1", "Query2", "Query3"]
results = graph_rag.batch_process(batch_queries)
print(f"Batch results: {results}")

Additional Resources

For those interested in diving deeper into the concepts and technologies behind GraphRAG applications, the following resources are recommended:

1. “Graph Neural Networks for Natural Language Processing” by Shikhar Vashishth et al. (2019) - Available on arXiv: https://arxiv.org/abs/1901.08746
2. “Knowledge Graphs” by Aidan Hogan et al. (2020) - Available on arXiv: https://arxiv.org/abs/2003.02320
3. “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks” by Patrick Lewis et al. (2020) - Available on arXiv: https://arxiv.org/abs/2005.11401

These papers provide in-depth discussions on graph-based approaches in natural language processing, knowledge representation, and retrieval-augmented generation techniques.

Closing Thoughts

GraphRAG is most useful when the problem requires relationship-aware retrieval, entity-level reasoning, or explainable traversal across connected knowledge. For simple FAQ retrieval, a conventional vector RAG pipeline may be sufficient. For research intelligence, compliance analysis, customer 360, fraud investigation, product recommendations, and enterprise knowledge systems, the graph layer can materially improve retrieval precision and traceability.

The practical design decision is not whether GraphRAG is more advanced than vector RAG. The real decision is whether the domain contains relationships that are important enough to model, query, and govern explicitly.

Related Reading

• Experiment Tracking in Machine Learning with Python
• Rotary Positional Embeddings RoPE in Python
• Workflow Management in LangChain