Enterprise-Grade GraphRAG: Deploying Neo4j and Ollama on a Linux VPS for Advanced Knowledge Retrieval

Introduction to the Next Evolution of Retrieval-Augmented Generation

In the rapidly evolving landscape of enterprise Artificial Intelligence, Retrieval-Augmented Generation (RAG) has become the gold standard for grounding Large Language Models (LLMs) in proprietary corporate data. However, traditional vector-based RAG architectures frequently encounter operational bottlenecks. They often struggle with global document summarizing, connecting disparate data points across an organization, and maintaining structural context. This is where GraphRAG comes into play.

By combining the structured, interconnected nature of Knowledge Graphs with the semantic capabilities of LLMs, GraphRAG allows organizations to query their data not just as isolated text chunks, but as a web of interconnected concepts. In this comprehensive guide, we will walk through the architecture, prerequisites, and step-by-step deployment of an enterprise-grade GraphRAG system using the Neo4j graph database and Ollama for localized LLM orchestration, hosted entirely on a secure Linux Virtual Private Server (VPS).

Why GraphRAG, Neo4j, and Ollama for Enterprise?

Before diving into the technical configuration, it is essential to understand why this specific stack represents a robust solution for modern enterprises:

• Neo4j: As the market-leading native graph database, Neo4j offers unparalleled performance for traversing complex relationships, executing Cypher queries efficiently, and scaling to billions of nodes and relationships.
• Ollama: Privacy and compliance dictate that many enterprises cannot leak sensitive data to third-party public APIs. Ollama provides a highly efficient, localized framework to run powerful open-source LLMs (like Llama 3 or Mistral) directly on your infrastructure.
• Linux VPS Deployment: Utilizing a self-hosted Linux VPS ensures complete data sovereignty, predictable infrastructure costing, and full customization over the networking and security boundaries of your AI pipeline.

Architecture Overview

An enterprise GraphRAG pipeline operates through a multi-stage lifecycle. First, unstructured data (PDFs, internal wikis, emails) is ingested and processed by an LLM to extract entities (e.g., organizations, people, concepts) and their explicit relationships. These entities and relationships are then structured and populated into Neo4j.

When a user submits a query, the system performs a hybrid search: a vector search for semantic similarity combined with a graph traversal to capture structural context. The aggregated knowledge graph context is then passed to the local Ollama instance, which generates an incredibly precise, context-aware response devoid of typical hallucinations.

Step 1: Preparing Your Linux VPS Environment

To support an enterprise-grade workload involving LLMs and graph data, your Linux VPS requires adequate provisioning. We recommend a minimum of 8 vCPUs, 32GB RAM, and high-speed NVMe storage. If you plan on hosting larger models (e.g., 70B parameters), a dedicated GPU VPS is highly recommended.

First, update your system packages and install the essential dependencies, including Docker and Docker Compose, which will simplify our deployment footprint:

sudo apt-get update && sudo apt-get upgrade -y
sudo apt-get install -y curl git apt-transport-https ca-certificates curl software-properties-common

Next, install the Docker engine to containerize our database and model environments securely:

curl -fsSL [https://download.docker.com/linux/ubuntu/gpg](https://download.docker.com/linux/ubuntu/gpg) | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] [https://download.docker.com/linux/ubuntu](https://download.docker.com/linux/ubuntu) $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.p/docker.list > /dev/null
sudo apt-get update && sudo apt-get install -y docker-ce docker-ce-cli containerd.io

Step 2: Deploying and Configuring Neo4j

With Docker installed, we can deploy Neo4j with the APOC (Awesome Procedures on Cypher) core library enabled, which is crucial for advanced data transformations and GraphRAG processing. Create a docker-compose.yml file in your project directory:

Configuration File Setup

Construct the environment variables to ensure the vector index extensions are ready for use:

version: '3.8'
services:
  neo4j:
    image: neo4j:5.18.0-enterprise
    container_name: enterprise_neo4j
    ports:
      - "7474:7474"
      - "7687:7687"
    volumes:
      - ./neo4j/data:/data
      - ./neo4j/logs:/logs
      - ./neo4j/import:/var/lib/neo4j/import
      - ./neo4j/plugins:/plugins
    environment:
      - NEO4J_AUTH=neo4j/YourSecureEnterprisePassword
      - NEO4J_PLUGINS=["apoc"]
      - NEO4J_dbms_security_procedures_unrestricted=apoc.*
      - NEO4J_dbms_security_procedures_allowlist=apoc.*

Launch the container using sudo docker-compose up -d. Verify that you can access the Neo4j Browser interface via http://your-vps-ip:7474 and authenticate with your configured credentials.

Step 3: Setting Up Ollama for Localized Inference

To establish data sovereignty, we will run our LLM locally using Ollama. Execute the official installation script directly on your VPS:

curl -fsSL [https://ollama.com/install.sh](https://ollama.com/install.sh) | sh

Once the installation completes, the Ollama service will run in the background. We need to download both a generative model (such as Llama3) and an embedding model (such as mxbai-embed-large) to generate the vector embeddings for our graph entities:

ollama pull llama3
ollama pull mxbai-embed-large

To verify that the service is running and accessible by your orchestration layer, perform a quick curl check against the local API endpoint: curl http://localhost:11434/api/tags.

Step 4: Implementing the GraphRAG Extraction Pipeline

With our storage engine (Neo4j) and inference engine (Ollama) active, we implement the pipeline orchestrator using Python. We utilize frameworks like LangChain or LlamaIndex to manage the extraction workflow.

1. Document Ingestion & Chunking

Raw text documents are ingested and broken down into overlapping chunks (e.g., 500 tokens with a 100-token overlap) to ensure continuity of context.

2. Entity-Relation Extraction

Each chunk is sent to Ollama. Using specialized prompting, the model extracts semantic triplets: (Subject, Predicate, Object). For example, "Company A acquired Company B in 2024" yields nodes for the companies and an "ACQUIRED" relationship.

3. Vector Indexing

We generate vector embeddings for both the textual descriptions of the nodes and the raw chunks, saving them directly inside Neo4j's vector index using Cypher commands:

CREATE VECTOR INDEX node_embeddings FOR (e:__Entity__) ON (e.embedding) OPTIONS {indexConfig: {`vector.dimensions`: 1024, `vector.similarity_function`: 'cosine'}}

Step 5: Executing Graph-Based Retrieval & Generation

When an enterprise user inputs a query, the application executes a highly efficient two-pronged search strategy:

1. Vector Search: The system looks up the top-K most semantically similar text chunks and entities within Neo4j using the query's embedding vector.
2. Sub-graph Subtraction: From those top-K nodes, the system traverses adjacent relationships up to 2 degrees of separation to pull the structural context that standard RAG would miss.

This unified context block—combining raw text fragments and explicit relationship descriptions—is compiled into an enterprise prompt template and dispatched to Ollama for the final, factual synthesis.

Security and Performance Best Practices

Operating a GraphRAG system at an enterprise scale on a Linux VPS requires adherence to strict production operational standards:

• Reverse Proxy and TLS: Never expose your Neo4j HTTP ports or Ollama APIs directly to the public internet. Utilize Nginx as a reverse proxy coupled with Let's Encrypt SSL certificates, combined with strict firewall rules via ufw to restrict access only to authorized IP addresses.
• Memory Management: Carefully tune Neo4j heap memory and pagecache configuration based on your VPS limits. Ensure that your Ollama models have enough unallocated system memory to load weights into RAM without triggering the Linux Out-Of-Memory (OOM) killer.
• Backup Strategies: Implement automated cron jobs executing neo4j-admin database backup to ensure quick disaster recovery capabilities.

Conclusion

By moving beyond standard vector databases to an integrated GraphRAG architecture powered by Neo4j and Ollama, your enterprise can unlock a dramatically more intelligent, context-aware, and secure AI capability. Operating this stack on a private Linux VPS delivers the ultimate combination of cost efficiency, performance control, and ironclad data sovereignty. As enterprise intelligence demands deep conceptual understanding over simple keywords, GraphRAG represents the definitive path forward.