Graph Database

GraphRAG Ready

Deploy FalkorDB on a RamNode VPS

A production-ready property graph database built as a Redis module — sparse adjacency matrices, GraphBLAS, OpenCypher, and built-in vector similarity search for knowledge graphs and GraphRAG.

At a Glance

Project	FalkorDB v4.18.2
Engine	Redis module · GraphBLAS
Query Language	OpenCypher (with extensions)
Recommended Plan	RamNode Cloud VPS 2–8 GB
OS	Ubuntu 24.04 LTS
Estimated Setup Time	15–25 minutes (Docker)

Pick a VPS Size

Evaluation (under 100k nodes): 1 vCPU, 1–2 GB RAM, 25 GB NVMe
GraphRAG sidecar (1M–10M nodes): 2–4 vCPU, 4–8 GB RAM, 50 GB NVMe
Heavy analytics: 4+ vCPU, 16 GB+ RAM — scale RAM with graph size

Keep maxmemory at roughly 70% of physical RAM, leaving headroom for the OS, AOF rewriting, and companion services.

Install Docker Engine (Recommended Path)

Upstream Docker repo

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker $USER

Log out and back in so the docker group membership applies.

Create the Compose Project

Project skeleton

sudo mkdir -p /opt/falkordb
sudo chown $USER:$USER /opt/falkordb
cd /opt/falkordb
mkdir data

.env

FALKORDB_PASSWORD=$(openssl rand -base64 32)
FALKORDB_THREADS=4
FALKORDB_MAX_MEMORY=2gb

docker-compose.yml

services:
  falkordb:
    image: falkordb/falkordb-server:v4.18.2
    container_name: falkordb
    restart: unless-stopped
    ports:
      - "127.0.0.1:6379:6379"
    environment:
      - REDIS_ARGS=--requirepass ${FALKORDB_PASSWORD} --appendonly yes --appendfsync everysec --maxmemory ${FALKORDB_MAX_MEMORY} --maxmemory-policy allkeys-lru
      - FALKORDB_ARGS=THREAD_COUNT ${FALKORDB_THREADS} CACHE_SIZE 50 TIMEOUT_DEFAULT 30000 TIMEOUT_MAX 60000 QUERY_MEM_CAPACITY 104857600
    volumes:
      - ./data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${FALKORDB_PASSWORD}", "ping"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 30s
    deploy:
      resources:
        limits:
          memory: 3G
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    sysctls:
      net.core.somaxconn: "511"

  falkordb-browser:
    image: falkordb/falkordb-browser:latest
    container_name: falkordb-browser
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    environment:
      - FALKORDB_URL=redis://default:${FALKORDB_PASSWORD}@falkordb:6379
    depends_on:
      falkordb:
        condition: service_healthy

Both services bind to 127.0.0.1 so nothing is exposed publicly. QUERY_MEM_CAPACITY caps a single query at 100 MB, preventing a runaway Cypher query from OOM-ing the box.

Bring It Up & Verify

Start

cd /opt/falkordb
docker compose up -d
docker compose ps
docker compose logs -f falkordb

Smoke test

source .env
docker exec -it falkordb redis-cli -a "$FALKORDB_PASSWORD" GRAPH.QUERY demo \
  "CREATE (n:Test {created: timestamp()}) RETURN n"

Alternative: Native Install with System Redis

If you'd rather avoid Docker, build the module against stock Redis 7.4+:

Build deps + Redis 7.4

sudo apt-get install -y build-essential cmake m4 automake peg libtool autoconf \
  python3 python3-pip git pkg-config libssl-dev

curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | \
  sudo tee /etc/apt/sources.list.d/redis.list
sudo apt-get update && sudo apt-get install -y redis

Build FalkorDB module

cd /usr/local/src
sudo git clone --recurse-submodules -j8 https://github.com/FalkorDB/FalkorDB.git
cd FalkorDB && sudo git checkout v4.18.2 && sudo make
sudo mkdir -p /usr/lib/redis/modules
sudo cp bin/linux-*-release/src/falkordb.so /usr/lib/redis/modules/
sudo chown -R redis:redis /usr/lib/redis/modules

/etc/redis/redis.conf additions

bind 127.0.0.1 ::1
protected-mode yes
requirepass YOUR_STRONG_PASSWORD_HERE
loadmodule /usr/lib/redis/modules/falkordb.so THREAD_COUNT 4 CACHE_SIZE 50 TIMEOUT_DEFAULT 30000 TIMEOUT_MAX 60000 QUERY_MEM_CAPACITY 104857600
appendonly yes
appendfsync everysec
maxmemory 2gb
maxmemory-policy allkeys-lru

Start + verify

sudo systemctl restart redis-server
sudo systemctl enable redis-server
redis-cli -a 'YOUR_PASSWORD' MODULE LIST

Secure the Deployment

Reach the database from your laptop via SSH tunnel rather than opening 6379 to the public:

SSH tunnel

ssh -L 6379:127.0.0.1:6379 -L 3000:127.0.0.1:3000 user@your-vps-ip

UFW source-restricted

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow from YOUR.OFFICE.IP.HERE to any port 6379
sudo ufw enable

Persistence and Backups

AOF (with appendfsync everysec) gives at most one second of data loss; RDB snapshots are smaller and ideal for offsite backup. Trigger a clean snapshot with BGSAVE before copying:

/usr/local/bin/falkordb-backup.sh

#!/bin/bash
set -euo pipefail
BACKUP_DIR="/var/backups/falkordb"
DATE=$(date +%Y%m%d-%H%M%S)
PASSWORD="YOUR_STRONG_PASSWORD_HERE"

mkdir -p "$BACKUP_DIR"
redis-cli -a "$PASSWORD" BGSAVE
sleep 5
cp /var/lib/redis/dump.rdb "$BACKUP_DIR/dump-$DATE.rdb"
gzip "$BACKUP_DIR/dump-$DATE.rdb"
find "$BACKUP_DIR" -name "dump-*.rdb.gz" -mtime +14 -delete

/etc/cron.d/falkordb-backup

0 3 * * * root /usr/local/bin/falkordb-backup.sh >> /var/log/falkordb-backup.log 2>&1

Kernel Tuning for Small VPS Plans

Disable Transparent Huge Pages

echo never | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
echo never | sudo tee /sys/kernel/mm/transparent_hugepage/defrag

sysctl tuning

echo "vm.overcommit_memory = 1" | sudo tee -a /etc/sysctl.conf
echo "net.core.somaxconn = 511"  | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

For graph data you usually want maxmemory-policy noeviction instead of LRU, paired with monitoring. Reserve 30% of RAM as OS headroom.

First Cypher Query — Tiny Knowledge Graph

Python client

pip install falkordb

example.py

from falkordb import FalkorDB

db = FalkorDB(host="localhost", port=6379, password="YOUR_PASSWORD")
g = db.select_graph("knowledge")

g.query("""
  CREATE
    (alice:Person {name: 'Alice', role: 'engineer'}),
    (bob:Person   {name: 'Bob',   role: 'researcher'}),
    (carol:Person {name: 'Carol', role: 'engineer'}),
    (graphdb:Topic {name: 'Graph Databases'}),
    (alice)-[:KNOWS {since: 2022}]->(bob),
    (bob)-[:KNOWS {since: 2024}]->(carol),
    (alice)-[:INTERESTED_IN]->(graphdb),
    (carol)-[:INTERESTED_IN]->(graphdb)
""")

result = g.query("""
  MATCH (alice:Person {name: 'Alice'})-[:INTERESTED_IN]->(t:Topic),
        (alice)-[:KNOWS*1..2]-(other:Person)-[:INTERESTED_IN]->(t)
  WHERE other.name <> 'Alice'
  RETURN DISTINCT other.name AS name, t.name AS shared_topic
""")
for r in result.result_set: print(r)

For GraphRAG, add a vector index alongside your graph traversals — same instance handles both:

Vector index

CREATE VECTOR INDEX FOR (n:Document) ON (n.embedding) OPTIONS {dimension: 1536, similarityFunction: 'cosine'}

FalkorDB Browser & Monitoring

With Docker the Browser UI is on http://localhost:3000 via your SSH tunnel. Connect with host falkordb, port 6379, user default, and the password from .env.

Health checks

redis-cli -a "$FALKORDB_PASSWORD" INFO memory
redis-cli -a "$FALKORDB_PASSWORD" INFO stats
redis-cli -a "$FALKORDB_PASSWORD" GRAPH.INFO QUERIES CURRENT

GRAPH.INFO QUERIES CURRENT shows live queries with execution time — kill a wedged one with GRAPH.QUERIES KILL <pid>. Point Prometheus at redis_exporter for ongoing metrics.

What's Next

GraphRAG: integrate the FalkorDB GraphRAG SDK with your LLM provider
Bulk loading: use falkordb-bulk-insert for large CSV ingests
HA: add a replica with replicaof in a second RamNode region
Indexing: CREATE INDEX FOR (p:Person) ON (p.name) — online and fast

More Deployment Guides•Neo4j Guide•View Cloud VPS Plans