# Graph RAG information (Neo4J, LlamaIndex, Groq API)

*What follows is a conversation I had with Anthropic's https://claude.ai/ LLM, asking it questions about how Graph RAG
works in as much detail as I could think of. When I think of graph databases, I normally think RDF, but the generally
preferred graph DB for LLM apps seems to be Neo4J which uses a query language called Cypher rather than SPARQL, so there
are some questions below about Neo4J and Cypher syntax. The thing I really wanted to know about was the sequence of queries
and responses involved, and how the queries are constructed, and how the responses are interpreted.*

## Prompt:
During a typical graph rag query and response, what would a langsmith trace look like?

## Response:
Let me create a visualization of what a typical LangSmith trace would look like for a RAG query using a graph database.

![LangSmith Trace for Graph RAG Query](https://gist.github.com/wware/4c9b2ea74f02b68c1ffa00b3a2d49b9a/raw/98621df0d8c47565d1e4b67fa5cf05e84fcb0f80/LangSmithTrace.png)

I've created a diagram showing a typical LangSmith trace for a graph RAG query. Here's what's happening in each major section:

1.  Query Construction Phase:
    *   Takes the raw user input
    *   Processes it into a structured format
    *   Generates the appropriate graph query
2.  Graph Retrieval Phase:
    *   Executes the query against the graph database
    *   Returns relevant subgraphs
    *   Processes the results
3.  Context Creation Phase:
    *   Formats the graph data for the LLM
    *   Creates an appropriate context window
4.  LLM Generation Phase:
    *   Sends the combined query and context to the LLM
    *   Processes and generates the final response

Each phase is tracked separately in LangSmith, allowing you to:

*   Monitor performance metrics
*   Debug bottlenecks
*   Track token usage
*   Analyze query patterns

Would you like me to expand on any particular phase or add more specific metrics to the trace visualization?

## Prompt:
How is the first step accomplished? I assume there is some prompt engineering magic involved?

## Response:
Yes, I'll break down the query construction phase and show how prompt engineering is typically used to transform a natural language query into a graph database query.

[Graph Query Construction with Prompt Engineering](#file-graphqueryconstructionprompt-py)

Let me explain the key components of the prompt engineering approach:

1.  **System Prompt Design**:
    *   Defines the role and expertise (graph query expert)
    *   Provides clear rules for query construction
    *   Includes the complete schema definition
    *   Sets expectations for output format
2.  **Schema Definition**:
    *   Lists all node types with their properties
    *   Defines relationship types and their attributes
    *   Helps the LLM understand the graph structure
3.  **Query Construction Rules**:
    *   Enforces consistent naming conventions
    *   Requires descriptive variable names
    *   Specifies when to use optional matches
    *   Includes guidance on result limiting
4.  **Implementation Features**:
    *   Uses zero temperature for deterministic outputs
    *   Returns only the query without explanations
    *   Handles various types of questions
    *   Maintains consistent formatting

Some example transformations this enables:

```
Natural: "Who does Alice work with?"
↓
Cypher: MATCH (alice:Person {name: 'Alice'})-[:WORKS_AT]->(company:Company)
       MATCH (coworker:Person)-[:WORKS_AT]->(company)
       WHERE coworker <> alice
       RETURN DISTINCT coworker.name, company.name
```

Would you like me to:

1.  Add more example transformations?
2.  Show how to handle more complex graph patterns?
3.  Explain how to validate the generated queries?

## Prompt:
I'm unfamiliar with the Cypher syntax. Where can I learn more about it?

## Response:
Let me create a beginner-friendly guide to Cypher's core syntax.

[Introduction to Cypher Query Language](#file-cypherlanguagebeginnerguide-md)

I've created a beginner's guide to Cypher. The key thing to remember is that Cypher queries are essentially pattern matching using ASCII art-like syntax. The queries visually represent what you're looking for in the graph.

For example, if you want to find people who work at companies:

```cypher
(person:Person)-[:WORKS_AT]->(company:Company)
```

This pattern literally looks like what it's matching: a person node, connected by a WORKS\_AT relationship, pointing to a company node.

Would you like me to:

1.  Show more specific examples for your use case?
2.  Explain any particular pattern in more detail?
3.  Demonstrate how to build more complex queries step by step?

## Prompt:
Is neo4j a triple store?

## Response:
No, Neo4j is not a triple store, though there are some important similarities and differences worth exploring.

![Triple Store vs Property Graph Model](https://gist.github.com/wware/4c9b2ea74f02b68c1ffa00b3a2d49b9a/raw/5a06c0ed12cc8bc5ad8fbce340edc66944a494f0/Property-Graph-vs-Triple-Store.png)

Key differences between Neo4j (a property graph database) and triple stores:

1.  **Data Model**:
    *   Triple Store: Data is stored as subject-predicate-object triples
    *   Neo4j: Uses labeled property graphs with:
        *   Nodes that can have multiple properties
        *   Relationships that can have properties
        *   Both nodes and relationships can have labels/types
2.  **Property Storage**:
    *   Triple Store: Properties are stored as additional triples
    *   Neo4j: Properties are stored directly on nodes and relationships
3.  **Query Language**:
    *   Triple Store: Usually SPARQL
    *   Neo4j: Cypher
4.  **Schema**:
    *   Triple Store: Often uses RDF Schema or OWL ontologies
    *   Neo4j: Schema-optional with optional constraints and indexes
5.  **Use Cases**:
    *   Triple Stores: Better for:
        *   Semantic web applications
        *   Linked data
        *   Ontology-based integration
    *   Neo4j: Better for:
        *   Complex relationship patterns
        *   Path finding
        *   Graph algorithms

To illustrate, here's how the same data might be represented:

```
# Triple Store (RDF)
:person/123 :name "John" .
:person/123 :works_at :company/456 .
:company/456 :name "Acme Corp" .

# Neo4j (Cypher)
CREATE (p:Person {id: 123, name: 'John'})
CREATE (c:Company {id: 456, name: 'Acme Corp'})
CREATE (p)-[:WORKS_AT {since: 2020}]->(c)
```

Would you like me to elaborate on any of these differences or explore specific use cases where one might be preferred over the other?

## Prompt:
OWL can express set theoretic ideas and other useful info about your entities, so you can structure your domain knowledge nicely. Is there anything equivalent for property graphs?

## Response:
Yes, property graphs can capture semantic information through Property Graph Schema (PGS) and Graph Data Science (GDS) capabilities, though it's structured differently from OWL.

![Property Graph Schema and Constraints](https://gist.github.com/wware/4c9b2ea74f02b68c1ffa00b3a2d49b9a/raw/894ac1c2cab4c623c36095c40bacfcd6d0da9a27/Property-Graph-Schema-and-Constraints.png)

Here are the key ways property graphs can express domain knowledge:

1.  **Node Label Hierarchies**:

```cypher
CREATE CONSTRAINT person_age IF NOT EXISTS
FOR (p:Person) REQUIRE p.age IS NOT NULL
    AND p.age >= 18;

CREATE CONSTRAINT employee_inherits IF NOT EXISTS
FOR (e:Employee) REQUIRE e:Person;
```

2.  **Property Constraints**:

```cypher
// Define required properties
CREATE CONSTRAINT person_name IF NOT EXISTS
FOR (p:Person) REQUIRE p.name IS NOT NULL;

// Define property types
CREATE CONSTRAINT person_age_type IF NOT EXISTS
FOR (p:Person) REQUIRE p.age IS INTEGER;

// Define value constraints
CREATE CONSTRAINT company_industry IF NOT EXISTS
FOR (c:Company) REQUIRE c.industry IN ['Tech', 'Finance', 'Healthcare'];
```

3.  **Relationship Cardinality**:

```cypher
// Ensure each Employee works at exactly one Company
CREATE CONSTRAINT employee_company IF NOT EXISTS
FOR ()-[r:WORKS_AT]->() 
REQUIRE r.since IS NOT NULL;

MATCH (e:Employee)
WITH e, count(()-[:WORKS_AT]->()) as company_count
WHERE company_count <> 1
RETURN e.name;
```

4.  **Semantic Rules via Procedures**:

```python
@procedure("domain.validateEmployeeHierarchy")
def validate_hierarchy(tx):
    # Check that no employee manages their manager
    query = """
    MATCH (e1:Employee)-[:MANAGES]->(e2:Employee)
    MATCH (e2)-[:MANAGES*]->(e1)
    RETURN e1.name, e2.name
    """
    return tx.run(query)
```

5.  **Graph Data Science for Inference**:

```cypher
// Find implicit relationships through pattern analysis
CALL gds.nodeSimilarity.stream({
    nodeProjection: ['Person'],
    relationshipProjection: {
        KNOWS: {
            type: 'KNOWS',
            orientation: 'UNDIRECTED'
        }
    }
})
```

Key differences from OWL:

1.  **Expressiveness**:
    *   OWL: Formal logic, supports complex reasoning
    *   PGS: More practical, focused on data integrity
2.  **Reasoning**:
    *   OWL: Built-in inference engine
    *   PGS: Custom procedures + Graph algorithms
3.  **Validation**:
    *   OWL: Logical consistency checking
    *   PGS: Constraint checking + Custom validation
4.  **Use Cases**:
    *   OWL: Knowledge representation, inference
    *   PGS: Data integrity, pattern matching

Would you like me to:

1.  Show more examples of how to implement specific OWL-like features in property graphs?
2.  Explain how to combine Graph Data Science with schema constraints?
3.  Demonstrate how to build custom inference rules?

## Prompt:
What does the asterisk in `[:MANAGES*]` mean?

## Response:
The asterisk `*` in Cypher indicates a variable-length path - it means "follow this relationship type zero or more times" (or in other words, traverse this relationship transitively). This is incredibly useful for hierarchical or recursive relationships.

Let me show you how it works:

![Variable-Length Path Matching in Cypher](https://gist.github.com/wware/4c9b2ea74f02b68c1ffa00b3a2d49b9a/raw/a51d03f27536749413d1eefe910817e85e10eb29/Variable-Length-Path-Matching-in-Cypher.png)

Here are the key variations of path matching:

```cypher
// Direct management (depth = 1)
MATCH (manager)-[:MANAGES]->(employee)
RETURN manager.name, employee.name;

// Exactly two levels down (depth = 2)
MATCH (manager)-[:MANAGES*2]->(employee)
RETURN manager.name, employee.name;

// Between 1 and 3 levels (1 ≤ depth ≤ 3)
MATCH (manager)-[:MANAGES*1..3]->(employee)
RETURN manager.name, employee.name;

// All levels down (any depth)
MATCH (manager)-[:MANAGES*]->(employee)
RETURN manager.name, employee.name;

// Zero or more levels (includes self)
MATCH (person)-[:MANAGES*0..]->(employee)
RETURN person.name, employee.name;
```

Common use cases include:

1.  **Organizational Hierarchies**:

```cypher
// Find all employees under a VP
MATCH (vp:Employee {title: 'VP'})-[:MANAGES*]->(employee)
RETURN employee.name;
```

2.  **Cycle Detection**:

```cypher
// Find circular management chains
MATCH (e:Employee)-[:MANAGES*]->(e)
RETURN e.name;
```

3.  **Level-specific Queries**:

```cypher
// Find skip-level reports (reports of reports)
MATCH (manager)-[:MANAGES*2]->(skip_level_report)
RETURN manager.name, skip_level_report.name;
```

4.  **Path Analysis**:

```cypher
// Find the management chain between two people
MATCH path = (e1:Employee)-[:MANAGES*]->(e2:Employee)
WHERE e1.name = 'Alice' AND e2.name = 'Eve'
RETURN [node in nodes(path) | node.name] as chain;
```

Would you like me to:

1.  Show more examples of variable-length patterns?
2.  Explain how to optimize queries with variable-length paths?
3.  Demonstrate how to combine this with other Cypher features?

## Prompt:
It sounds like neo4j is the de facto standard graph database for graph rag applications, is that right? Are any other graph Dbs in common usage?

## Response:
Neo4j is very popular for graph RAG applications, but there are several other significant players in this space. Let me break this down.

#### Graph Databases in RAG Applications

*There was a document here showing some different databases but somehow the document
got corrupted so this information was lost.*

Some key observations about the current landscape:

1.  **Neo4j's Popularity** comes from:
    *   Large existing userbase
    *   Strong integration with common RAG frameworks
    *   Good documentation for AI/ML use cases
    *   Vector search capabilities
2.  **Emerging Trends**:
    *   Many databases are adding native vector support
    *   Hybrid architectures becoming more common
    *   Focus on scalability and real-time updates
3.  **Selection Factors**:
    *   Scale of data
    *   Query patterns
    *   Infrastructure requirements
    *   Team expertise
    *   Cost considerations

Would you like me to:

1.  Dive deeper into any particular database?
2.  Explain specific RAG integration patterns?
3.  Compare query languages across these databases?

## Prompt:
Is neo4j available as a docker image? If so, what docker-run options are typically used with it?

## Response:
Yes, Neo4j is available as a Docker image. Let me show you the typical Docker setup.

#### Neo4j Docker Configuration

```
# Basic docker run command
docker run \
    --name neo4j \
    -p 7474:7474 -p 7687:7687 \
    -v $HOME/neo4j/data:/data \
    -v $HOME/neo4j/logs:/logs \
    -v $HOME/neo4j/import:/var/lib/neo4j/import \
    -v $HOME/neo4j/plugins:/plugins \
    --env NEO4J_AUTH=neo4j/password123 \
    --env NEO4J_ACCEPT_LICENSE_AGREEMENT=yes \
    neo4j:5.13.0-enterprise

# Docker Compose file for more complete setup
version: '3'
services:
  neo4j:
    image: neo4j:5.13.0-enterprise
    container_name: neo4j
    ports:
      - "7474:7474"  # HTTP
      - "7687:7687"  # Bolt
      - "7473:7473"  # HTTPS
    volumes:
      - ./data:/data
      - ./logs:/logs
      - ./import:/var/lib/neo4j/import
      - ./plugins:/plugins
      - ./conf:/conf
    environment:
      # Authentication
      - NEO4J_AUTH=neo4j/password123
      - NEO4J_ACCEPT_LICENSE_AGREEMENT=yes
      
      # Memory Configuration
      - NEO4J_server_memory_heap_initial__size=2G
      - NEO4J_server_memory_heap_max__size=2G
      - NEO4J_server_memory_pagecache_size=1G
      
      # Connection Configuration
      - NEO4J_server_default__listen__address=0.0.0.0
      - NEO4J_server_bolt_advertised__address=:7687
      - NEO4J_server_http_advertised__address=:7474
      
      # APOC Configuration
      - NEO4J_dbms_security_procedures_unrestricted=apoc.*,gds.*
      - NEO4J_dbms_security_procedures_allowlist=apoc.*,gds.*
      
      # GDS Configuration
      - NEO4J_gds_enterprise_license__file=/conf/gds.license
      
      # Logging
      - NEO4J_dbms_logs_debug_level=INFO
      
    ulimits:
      nofile:
        soft: 40000
        hard: 40000
    restart: unless-stopped
    networks:
      - neo4j_network

networks:
  neo4j_network:
    driver: bridge
```

Let me explain the key components:

1.  **Essential Ports**:
    *   7474: HTTP for browser interface
    *   7687: Bolt protocol for database connections
    *   7473: HTTPS (optional)
2.  **Important Volumes**:
    *   `/data`: Database files
    *   `/logs`: Log files
    *   `/import`: For importing data files
    *   `/plugins`: Custom plugins/extensions
    *   `/conf`: Configuration files
3.  **Common Environment Variables**:

```bash
# Basic Setup
NEO4J_AUTH=neo4j/yourpassword  # Set initial password
NEO4J_ACCEPT_LICENSE_AGREEMENT=yes  # Required for enterprise

# Memory Configuration
NEO4J_server_memory_heap_initial__size=2G
NEO4J_server_memory_heap_max__size=2G
NEO4J_server_memory_pagecache_size=1G

# APOC and GDS (Graph Data Science)
NEO4J_dbms_security_procedures_unrestricted=apoc.*,gds.*
```

4.  **Quick Start Command**:

```bash
docker run --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -v $HOME/neo4j/data:/data \
  -e NEO4J_AUTH=neo4j/password123 \
  neo4j:latest
```

5.  **Development vs Production**:

```bash
# Development
docker run --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -v $HOME/neo4j/data:/data \
  -e NEO4J_AUTH=neo4j/password123 \
  -e NEO4J_ACCEPT_LICENSE_AGREEMENT=yes \
  -e NEO4J_server_memory_heap_max__size=512M \
  neo4j:latest

# Production
docker run --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -v /path/to/data:/data \
  -v /path/to/logs:/logs \
  -v /path/to/import:/var/lib/neo4j/import \
  -v /path/to/plugins:/plugins \
  -e NEO4J_AUTH=neo4j/strongpassword \
  -e NEO4J_ACCEPT_LICENSE_AGREEMENT=yes \
  -e NEO4J_server_memory_heap_max__size=16G \
  -e NEO4J_server_memory_pagecache_size=4G \
  --ulimit nofile=40000:40000 \
  --restart unless-stopped \
  neo4j:enterprise
```

Would you like me to:

1.  Explain any specific configuration options in more detail?
2.  Show how to set up clustering with Docker?
3.  Demonstrate how to integrate with other services (like vector databases)?

## Prompt:
Let's assume I want to build a Neo4J-based graph RAG system using the earlier Python code for constructing prompts
and I want to do this in docker-compose using the official Neo4J docker image for one of my containers. And for the LLM, I want to use the public Groq API, accessed by either LangChain or LlamaIndex. Please show me the docker-compose.yml file I would need to do this.

## Response:
I'll help you create a docker-compose file that sets up a Neo4j container and a Python service that can interact with both Neo4j and Groq's API.

#### Docker Compose Configuration for Neo4j Graph RAG System

```
version: '3.8'

services:
  neo4j:
    image: neo4j:5.13.0
    container_name: neo4j-graph-rag
    ports:
      - "7474:7474"  # HTTP
      - "7687:7687"  # Bolt
    environment:
      - NEO4J_AUTH=neo4j/your_password_here
      - NEO4J_PLUGINS=["graph-data-science", "apoc"]  # Optional but recommended plugins
      - NEO4J_dbms_memory_heap_initial__size=512M
      - NEO4J_dbms_memory_heap_max__size=2G
      - NEO4J_dbms_memory_pagecache_size=512M
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
      - neo4j_import:/import
      - neo4j_plugins:/plugins
    networks:
      - graph-rag-network

  rag-service:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: rag-service
    depends_on:
      - neo4j
    environment:
      - NEO4J_URI=bolt://neo4j:7687
      - NEO4J_USER=neo4j
      - NEO4J_PASSWORD=your_password_here
      - GROQ_API_KEY=your_groq_api_key_here
    volumes:
      - ./app:/app
    networks:
      - graph-rag-network
    command: python main.py  # Adjust based on your entry point

networks:
  graph-rag-network:
    driver: bridge

volumes:
  neo4j_data:
  neo4j_logs:
  neo4j_import:
  neo4j_plugins:
```

You'll also need a Dockerfile for the rag-service. Here it is:

#### Dockerfile for RAG Service

```
FROM python:3.11-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Copy requirements file
COPY requirements.txt .

# Install Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY ./app .

CMD ["python", "main.py"]
```

#### And here's a minimal requirements.txt file you'll need:

Python Requirements

```
langchain
langchain-groq
neo4j
python-dotenv
llama-index
llama-index-vector-stores-neo4j
```

To use this setup:

1.  Create a project directory with the following structure:

```
project/
├── docker-compose.yml
├── Dockerfile
├── requirements.txt
└── app/
    └── main.py  # Your application code
```

2.  Important notes:
    *   Replace `your_password_here` with a secure password for Neo4j
    *   Replace `your_groq_api_key_here` with your actual Groq API key
    *   The Neo4j container includes optional but recommended plugins (APOC and Graph Data Science)
    *   The Neo4j data, logs, and plugins are persisted using named volumes
    *   The services are connected via a dedicated network named `graph-rag-network`
    *   The Python service waits for Neo4j to be ready before starting
    *   Memory settings for Neo4j are conservative and can be adjusted based on your needs
3.  To start the services:

```bash
docker-compose up -d
```

4.  Access points:
    *   Neo4j Browser: [http://localhost:7474](http://localhost:7474)
    *   Neo4j Bolt: bolt://localhost:7687
    *   Your RAG service will run inside its container and can communicate with Neo4j using the internal network

Would you like me to show you how to modify the Python code you provided to work with this Docker setup, or would you like to see how to configure environment variables for better security?

## Prompt:
Please show me what a simple application would look like in Python, using LlamaIndex to access the Groq API, in a system like the one described above.

## Response:
I'll create a simple application that demonstrates using LlamaIndex with Groq and Neo4j for graph-based RAG.

#### Graph RAG Application using LlamaIndex, Groq, and Neo4j

```
import os
from typing import List, Dict
from dotenv import load_dotenv
from llama_index import ServiceContext, VectorStoreIndex
from llama_index.llms import Groq
from llama_index.vector_stores.neo4j import Neo4jVectorStore
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.schema import Document
from neo4j import GraphDatabase

# Load environment variables
load_dotenv()

class GraphRAGSystem:
    def __init__(self):
        # Initialize Neo4j connection
        self.neo4j_uri = os.getenv("NEO4J_URI", "bolt://neo4j:7687")
        self.neo4j_user = os.getenv("NEO4J_USER", "neo4j")
        self.neo4j_password = os.getenv("NEO4J_PASSWORD")
        
        # Initialize Groq
        self.groq_api_key = os.getenv("GROQ_API_KEY")
        
        # Set up LlamaIndex components
        self.llm = Groq(
            api_key=self.groq_api_key,
            model_name="mixtral-8x7b-32768"  # or "llama2-70b-4096"
        )
        
        # Use HuggingFace embeddings (all-MiniLM-L6-v2 is a good default)
        self.embed_model = HuggingFaceEmbedding(
            model_name="sentence-transformers/all-MiniLM-L6-v2"
        )
        
        # Create Neo4j vector store
        self.vector_store = Neo4jVectorStore(
            url=self.neo4j_uri,
            username=self.neo4j_user,
            password=self.neo4j_password,
            embedding_dimension=384,  # matches the dimension of all-MiniLM-L6-v2
            index_name="document_index",
            node_label="Document",
            embedding_field="embedding",
            text_field="text"
        )
        
        # Create service context
        self.service_context = ServiceContext.from_defaults(
            llm=self.llm,
            embed_model=self.embed_model
        )
        
        # Initialize the index
        self.index = VectorStoreIndex.from_vector_store(
            vector_store=self.vector_store,
            service_context=self.service_context
        )

    def add_documents(self, documents: List[Dict[str, str]]) -> None:
        """
        Add documents to the vector store.
        
        Args:
            documents: List of dictionaries containing 'text' and optional metadata
        """
        doc_objects = [
            Document(text=doc['text'], metadata=doc.get('metadata', {}))
            for doc in documents
        ]
        
        self.index.insert_nodes(doc_objects)
        
    def query(self, query_text: str, response_mode: str = "compact") -> str:
        """
        Query the RAG system.
        
        Args:
            query_text: The question or query text
            response_mode: One of "compact", "tree_summarize", or "accumulate"
            
        Returns:
            str: The generated response
        """
        query_engine = self.index.as_query_engine(
            response_mode=response_mode
        )
        response = query_engine.query(query_text)
        return str(response)
    
    def add_graph_relationship(self, source_id: str, target_id: str, 
                             relationship_type: str, properties: Dict = None) -> None:
        """
        Add a relationship between two nodes in the graph.
        
        Args:
            source_id: ID of the source node
            target_id: ID of the target node
            relationship_type: Type of relationship
            properties: Optional dictionary of relationship properties
        """
        with GraphDatabase.driver(self.neo4j_uri, 
                                auth=(self.neo4j_user, self.neo4j_password)) as driver:
            with driver.session() as session:
                cypher = (
                    f"MATCH (a), (b) "
                    f"WHERE id(a) = $source_id AND id(b) = $target_id "
                    f"CREATE (a)-[r:{relationship_type} $props]->(b) "
                    f"RETURN type(r)"
                )
                session.run(cypher, 
                          source_id=source_id, 
                          target_id=target_id, 
                          props=properties or {})

def main():
    # Initialize the RAG system
    rag_system = GraphRAGSystem()
    
    # Example documents
    example_docs = [
        {
            "text": "Neo4j is a graph database management system developed by Neo4j, Inc.",
            "metadata": {"type": "definition", "topic": "databases"}
        },
        {
            "text": "Graph databases store data in nodes connected by relationships.",
            "metadata": {"type": "concept", "topic": "databases"}
        }
    ]
    
    # Add documents to the system
    rag_system.add_documents(example_docs)
    
    # Example query
    query = "What is Neo4j and how does it store data?"
    response = rag_system.query(query)
    print(f"\nQuery: {query}")
    print(f"Response: {response}")

if __name__ == "__main__":
    main()
```

This application provides:

1.  A complete `GraphRAGSystem` class that integrates:
    *   Neo4j for graph storage
    *   Groq's LLM API (using Mixtral-8x7b)
    *   LlamaIndex for RAG functionality
    *   HuggingFace embeddings for vector search
2.  Key features:
    *   Document ingestion with metadata support
    *   Vector similarity search
    *   Graph relationship management
    *   Flexible querying with different response modes
3.  Configuration through environment variables:

```bash
NEO4J_URI=bolt://neo4j:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=your_password_here
GROQ_API_KEY=your_groq_api_key_here
```

To use this in your Docker setup:

1.  Save the code as `app/main.py`
2.  Create a `.env` file in your project root:
    
    .env Configuration
    
    ```
    NEO4J_URI=bolt://neo4j:7687
    NEO4J_USER=neo4j
    NEO4J_PASSWORD=your_password_here
    GROQ_API_KEY=your_groq_api_key_here
    ```
    
3.  Update the requirements.txt to include additional dependencies:
    
    Updated Python Requirements
    
    ```
    langchain
    langchain-groq
    neo4j
    python-dotenv
    llama-index
    llama-index-vector-stores-neo4j
    llama-index-llms-groq
    sentence-transformers
    ```

The system will:

*   Store document embeddings in Neo4j
*   Use Groq's API for question answering
*   Support graph relationships between documents
*   Allow for metadata-aware querying

Would you like me to show you how to extend this with more advanced features like:

*   Custom query templates
*   Relationship-aware querying
*   Hybrid search (combining vector and graph traversal)
*   Or something else specific to your use case?