FalkorDB Docker: Production Deployment with Persistence, Clustering, and GraphRAG-SDK

By Fadi Updated Jul 31, 2025 13 min read Knowledge Graphs

TL;DR — FalkorDB Docker: production deployment, persistence, clustering, GraphRAG. Docker Docs: "docker run -p 6379:6379 -p 3000:3000 falkordb/falkordb. Production: falkordb/falkordb-server (lighter, no browser). Compose with persistence, password, healthcheck, logging." Persistence: "Volume: -v falkordb_data:/var/lib/falkordb/data. AOF: --appendonly yes. Data survives restarts." Cluster: "6 nodes, 3 masters + 3 replicas, 16,384 hash slots, redis-cli --cluster create." GraphRAG-SDK: "pip install graphrag-sdk[litellm], GraphRAG(connection, llm, embedder), ingest, finalize, completion with provenance." Learn more with FalkorDB vs Neo4j, GraphRAG tutorial, knowledge graph basics, and Ollama Docker.

FalkorDB Docker Docs introduces the setup: "Docker Compose provides a more flexible and maintainable way to run FalkorDB, especially when you need to configure multiple services or manage complex setups."

FalkorDB Operations adds: "For production deployments, consider using the falkordb/falkordb-server Docker image which is optimized for production use and doesn't include the FalkorDB Browser, making it lighter and more efficient."

FalkorDB Docker Architecture

flowchart TD subgraph Images["Docker Images"] Dev["falkordb/falkordb
Development
includes Browser UI
port 6379 + 3000
heavier image"] Prod["falkordb/falkordb-server
Production
no Browser UI
port 6379 only
lighter, efficient"] Browser["falkordb/falkordb-browser
Standalone Browser
connects to server
port 3000
FALKORDB_URL + PASSWORD"] end subgraph Persistence["Data Persistence"] Volume["Docker Volume
-v falkordb_data:/var/lib/falkordb/data
survives container restarts
named volumes recommended"] AOF["AOF Logging
--appendonly yes
--appendfsync everysec
durable writes"] RDB["RDB Snapshots
periodic point-in-time
backup snapshots
complements AOF"] ACL["ACL Persistence
--aclfile on mounted volume
users, passwords, permissions
survive restarts"] end subgraph Config["Configuration"] Redis["REDIS_ARGS
--requirepass password
--appendonly yes
--maxmemory 2gb
--maxmemory-policy allkeys-lru"] Falkor["FALKORDB_ARGS
THREAD_COUNT 8
CACHE_SIZE 50
TIMEOUT_MAX 60000
TIMEOUT_DEFAULT 30000
QUERY_MEM_CAPACITY 104857600"] Health["Health Check
redis-cli ping
interval 30s
timeout 10s
retries 5
start_period 30s"] Log["Logging
json-file driver
max-size 10m
max-file 3
log rotation"] end subgraph Cluster["Clustering"] Nodes["6 Nodes
3 masters + 3 replicas
--cluster-enabled yes
--cluster-announce-ip
--cluster-announce-port"] Slots["Hash Slots
16,384 slots
distributed across masters
each graph on one shard
hash of graph name"] Create["Create Cluster
redis-cli --cluster create
node1:6379 ...
--cluster-replicas 1
--cluster-yes"] Scale["Scaling
redis-cli --cluster add-node
rebalances hash slots
3 masters minimum
for fault tolerance"] end subgraph GraphRAG["GraphRAG-SDK"] SDK["graphrag-sdk
pip install graphrag-sdk[litellm]
ConnectionConfig(host, graph_name)
LiteLLM(model)
LiteLLMEmbedder(model, dims)"] Ingest["Ingestion
rag.ingest(text, document_id)
extracts nodes + edges
rag.finalize()
dedup, embeddings, indexes"] Query["Query
rag.completion(query)
full RAG with provenance
MENTIONS edges for citations
return_context=True"] Incremental["Incremental
apply_changes()
added/modified/deleted
crash-safe rollforward
CI use case: PR merge"] end Prod --> Volume Prod --> AOF Prod --> RDB Prod --> ACL Prod --> Redis Prod --> Falkor Prod --> Health Prod --> Log Prod --> Nodes Nodes --> Slots Slots --> Create Create --> Scale SDK --> Ingest Ingest --> Query Query --> Incremental style Images fill:#4169E1,color:#fff style Persistence fill:#39FF14,color:#000 style Config fill:#2D1B69,color:#fff style Cluster fill:#FF6B6B,color:#fff

Deployment Configurations

Setup	Image	Ports	Use Case	Key Features
Development	falkordb/falkordb	6379, 3000	Local dev	Built-in browser, easy start
Production	falkordb/falkordb-server	6379	Production	Lighter, no browser, efficient
Server + Browser	server + browser	6379, 3000	Production with UI	Separate browser container
Cluster	falkordb/falkordb	6379-6384	Scale	3 masters + 3 replicas, sharding

Implementation

from dataclasses import dataclass
from typing import Optional
from enum import Enum

class DeploymentType(Enum):
    DEV = "dev"
    PRODUCTION = "production"
    CLUSTER = "cluster"

@dataclass
class FalkorDBDockerGuide:
    """FalkorDB Docker deployment guide."""

    def get_dev_setup(self) -> str:
        """Development Docker setup."""
        return (
            "# === DEVELOPMENT SETUP ===\n"
            "\n"
            "# Quick start (with browser)\n"
            "docker run -d \\\n"
            "  -p 6379:6379 \\\n"
            "  -p 3000:3000 \\\n"
            "  --name falkordb \\\n"
            "  falkordb/falkordb:latest\n"
            "\n"
            "# Browser: http://localhost:3000\n"
            "# Redis port: localhost:6379\n"
            "\n"
            "# Python connection\n"
            "from falkordb import FalkorDB\n"
            "db = FalkorDB(\n"
            "    host='localhost',\n"
            "    port=6379)\n"
            "graph = db.select_graph('mygraph')\n"
            "\n"
            "# Quick Cypher query\n"
            "graph.query('''\n"
            "    CREATE\n"
            "      (:Person {name:'Alice'})\n"
            "      -[:WORKS_AT]->\n"
            "      (:Company {name:'Acme'})\n"
            "''')\n"
            "result = graph.query(\n"
            "    'MATCH (p)-[:WORKS_AT]->(c)\n"
            "     RETURN p.name, c.name')\n"
            "for row in result.result_set:\n"
            "    print(row)"
        )

    def get_production_compose(self) -> str:
        """Production Docker Compose setup."""
        return (
            "# === PRODUCTION DOCKER COMPOSE ===\n"
            "# docker-compose.yml\n"
            "\n"
            "version: '3.8'\n"
            "\n"
            "services:\n"
            "  falkordb:\n"
            "    image:\n"
            "      falkordb/falkordb-server:latest\n"
            "    container_name:\n"
            "      falkordb-production\n"
            "    ports:\n"
            "      - '6379:6379'\n"
            "    environment:\n"
            "      # Redis Configuration\n"
            "      - REDIS_ARGS=--requirepass\n"
            "          ${FALKORDB_PASSWORD:-changeme}\n"
            "          --appendonly yes\n"
            "          --appendfsync everysec\n"
            "          --maxmemory 2gb\n"
            "          --maxmemory-policy\n"
            "            allkeys-lru\n"
            "      # FalkorDB Configuration\n"
            "      - FALKORDB_ARGS=THREAD_COUNT 8\n"
            "          CACHE_SIZE 50\n"
            "          TIMEOUT_MAX 60000\n"
            "          TIMEOUT_DEFAULT 30000\n"
            "          QUERY_MEM_CAPACITY\n"
            "            104857600\n"
            "    volumes:\n"
            "      - falkordb_data:/data\n"
            "      - ./falkordb-config:/etc/falkordb\n"
            "    restart: unless-stopped\n"
            "    healthcheck:\n"
            "      test: ['CMD', 'redis-cli',\n"
            "        '-a',\n"
            "        '$${FALKORDB_PASSWORD:-changeme}',\n"
            "        'ping']\n"
            "      interval: 30s\n"
            "      timeout: 10s\n"
            "      retries: 5\n"
            "      start_period: 30s\n"
            "    networks:\n"
            "      - falkordb-network\n"
            "    logging:\n"
            "      driver: 'json-file'\n"
            "      options:\n"
            "        max-size: '10m'\n"
            "        max-file: '3'\n"
            "\n"
            "  falkordb-browser:\n"
            "    image:\n"
            "      falkordb/falkordb-browser:latest\n"
            "    container_name:\n"
            "      falkordb-browser\n"
            "    ports:\n"
            "      - '3000:3000'\n"
            "    environment:\n"
            "      - FALKORDB_URL=redis://\n"
            "          falkordb:6379\n"
            "      - FALKORDB_PASSWORD=\n"
            "          ${FALKORDB_PASSWORD:-changeme}\n"
            "    depends_on:\n"
            "      - falkordb\n"
            "    restart: unless-stopped\n"
            "    networks:\n"
            "      - falkordb-network\n"
            "\n"
            "volumes:\n"
            "  falkordb_data:\n"
            "\n"
            "networks:\n"
            "  falkordb-network:\n"
            "    driver: bridge"
        )

    def get_persistence(self) -> str:
        """FalkorDB persistence configuration."""
        return (
            "# === PERSISTENCE ===\n"
            "\n"
            "# 1. Create Docker volume\n"
            "docker volume create falkordb_data\n"
            "\n"
            "# 2. Start with persistent volume\n"
            "docker run -d \\\n"
            "  --name falkordb \\\n"
            "  -v falkordb_data:/var/lib/falkordb/data \\\n"
            "  -p 6379:6379 \\\n"
            "  falkordb/falkordb\n"
            "\n"
            "# 3. Enable AOF for durability\n"
            "docker run -d \\\n"
            "  --name falkordb \\\n"
            "  -v falkordb_data:/var/lib/falkordb/data \\\n"
            "  -p 6379:6379 \\\n"
            "  -e REDIS_ARGS='--appendonly yes\n"
            "    --appendfsync everysec' \\\n"
            "  falkordb/falkordb-server\n"
            "\n"
            "# 4. Test persistence\n"
            "# Create data\n"
            "redis-cli GRAPH.QUERY mygraph\n"
            "  \"CREATE (:Database\n"
            "   {name:'falkordb'})\"\n"
            "\n"
            "# Stop and restart\n"
            "docker stop falkordb\n"
            "docker start falkordb\n"
            "\n"
            "# Verify data persists\n"
            "redis-cli GRAPH.QUERY mygraph\n"
            "  \"MATCH (n) RETURN n\"\n"
            "\n"
            "# 5. ACL persistence\n"
            "# ACL users stored separately\n"
            "# Configure --aclfile on volume\n"
            "docker run -d \\\n"
            "  -v falkordb_data:/var/lib/falkordb/data \\\n"
            "  -e REDIS_ARGS='--appendonly yes\n"
            "    --aclfile\n"
            "    /var/lib/falkordb/data/acl.conf' \\\n"
            "  falkordb/falkordb-server"
        )

    def get_cluster_setup(self) -> str:
        """FalkorDB cluster setup."""
        return (
            "# === CLUSTER SETUP ===\n"
            "\n"
            "# 1. Create network\n"
            "docker network create \\\n"
            "  falkordb-cluster-network\n"
            "\n"
            "# 2. Launch 6 nodes\n"
            "for i in {1..6}; do\n"
            "  docker run -d \\\n"
            "    --name node$i \\\n"
            "    --hostname node$i \\\n"
            "    --network\n"
            "      falkordb-cluster-network \\\n"
            "    -p $((6379 + i - 1)):$((6379 + i - 1)) \\\n"
            "    -e BROWSER=0 \\\n"
            "    -e FALKORDB_ARGS=\"--port\n"
            "      $((6379 + i - 1))\n"
            "      --cluster-enabled yes\n"
            "      --cluster-announce-ip node$i\n"
            "      --cluster-announce-port\n"
            "      $((6379 + i - 1))\" \\\n"
            "    falkordb/falkordb\n"
            "done\n"
            "\n"
            "# 3. Create cluster\n"
            "docker exec -it node1 redis-cli \\\n"
            "  --cluster create \\\n"
            "  node1:6379 node2:6380 \\\n"
            "  node3:6381 node4:6382 \\\n"
            "  node5:6383 node6:6384 \\\n"
            "  --cluster-replicas 1 \\\n"
            "  --cluster-yes\n"
            "\n"
            "# 4. Verify cluster\n"
            "docker exec -it node1 \\\n"
            "  redis-cli --cluster check \\\n"
            "  node1:6379\n"
            "\n"
            "# 5. Scale: add node\n"
            "docker run -d --name node7 \\\n"
            "  --network\n"
            "    falkordb-cluster-network \\\n"
            "  -e BROWSER=0 \\\n"
            "  -e FALKORDB_ARGS=\"--port 6385\n"
            "    --cluster-enabled yes\n"
            "    --cluster-announce-ip node7\n"
            "    --cluster-announce-port 6385\" \\\n"
            "  falkordb/falkordb\n"
            "\n"
            "docker exec -it node1 redis-cli \\\n"
            "  --cluster add-node \\\n"
            "  node7:6385 node1:6379\n"
            "\n"
            "# 3 masters minimum for\n"
            "#   fault tolerance\n"
            "# 16,384 hash slots\n"
            "#   distributed evenly"
        )

    def get_graphrag_sdk(self) -> str:
        """GraphRAG-SDK with FalkorDB Docker."""
        return (
            "# === GRAPHRAG-SDK ===\n"
            "# pip install graphrag-sdk[litellm]\n"
            "# For PDF: pip install\n"
            "#   graphrag-sdk[litellm,pdf]\n"
            "\n"
            "import asyncio\n"
            "from graphrag_sdk import (\n"
            "    GraphRAG, ConnectionConfig,\n"
            "    LiteLLM, LiteLLMEmbedder)\n"
            "\n"
            "async def main():\n"
            "    async with GraphRAG(\n"
            "        connection=ConnectionConfig(\n"
            "            host='localhost',\n"
            "            graph_name='my_graph'),\n"
            "        llm=LiteLLM(\n"
            "            model='openai/gpt-4o-mini'),\n"
            "        embedder=LiteLLMEmbedder(\n"
            "            model='openai/\n"
            "              text-embedding-3-large',\n"
            "            dimensions=256),\n"
            "    ) as rag:\n"
            "        # 1. Ingest text\n"
            "        result = await rag.ingest(\n"
            "            text='Alice Johnson is'\n"
            "            ' a software engineer'\n"
            "            ' at Acme Corp in'\n"
            "            ' London.',\n"
            "            document_id='doc_1')\n"
            "        print(\n"
            "            f'Nodes: {result.nodes_created}'\n"
            "            f', Edges: '\n"
            "            f'{result.relationships_created}')\n"
            "\n"
            "        # 2. Finalize\n"
            "        await rag.finalize()\n"
            "        # Dedup entities,\n"
            "        #   backfill embeddings,\n"
            "        #   build indexes\n"
            "\n"
            "        # 3. Query with RAG\n"
            "        answer = await rag.completion(\n"
            "            'Where does Alice work?')\n"
            "        print(answer.answer)\n"
            "\n"
            "        # 4. With provenance\n"
            "        answer = await rag.completion(\n"
            "            'Where does Alice work?',\n"
            "            return_context=True)\n"
            "        # MENTIONS edges trace\n"
            "        #   to source chunks\n"
            "\n"
            "        # 5. Incremental update\n"
            "        await rag.apply_changes(\n"
            "            added=[('doc_2',\n"
            "              'Bob joined Acme.')],\n"
            "            modified=[],\n"
            "            deleted=['doc_1'])\n"
            "        # Crash-safe\n"
            "        #   rollforward cutover\n"
            "\n"
            "asyncio.run(main())\n"
            "\n"
            "# Multi-tenant: different\n"
            "#   graph_name per tenant\n"
            "#   in single FalkorDB instance"
        )

    def get_config_reference(self) -> dict:
        """Configuration reference."""
        return {
            "redis_args": {
                "requirepass": "Set password for authentication",
                "appendonly": "Enable AOF persistence (yes/no)",
                "appendfsync": "AOF sync policy: everysec (recommended), always, no",
                "maxmemory": "Maximum memory limit (e.g., 2gb)",
                "maxmemory_policy": "Eviction policy: allkeys-lru recommended",
                "aclfile": "Path to ACL file for user persistence",
            },
            "falkordb_args": {
                "THREAD_COUNT": "Number of worker threads (default 8)",
                "CACHE_SIZE": "Query cache size (default 50)",
                "TIMEOUT_MAX": "Max query timeout in ms (default 60000)",
                "TIMEOUT_DEFAULT": "Default query timeout in ms (default 30000)",
                "QUERY_MEM_CAPACITY": "Max memory per query in bytes",
            },
            "volumes": {
                "data": "/var/lib/falkordb/data — default data directory",
                "config": "/etc/falkordb — optional config directory",
                "named": "Named volumes recommended (portable, easy management)",
                "bind": "Bind mounts for specific host directory mapping",
            },
            "healthcheck": {
                "test": "redis-cli ping (or with -a password)",
                "interval": "30s",
                "timeout": "10s",
                "retries": "5",
                "start_period": "30s",
            },
        }

FalkorDB Docker Checklist

[ ] Development: docker run -p 6379:6379 -p 3000:3000 falkordb/falkordb:latest
[ ] Production: use falkordb/falkordb-server (lighter, no browser, more efficient)
[ ] Development: falkordb/falkordb includes FalkorDB Browser at http://localhost:3000
[ ] Docker Compose for multi-service deployments (server + browser)
[ ] Persistent volume: -v falkordb_data:/var/lib/falkordb/data — data survives restarts
[ ] FalkorDB stores data in /var/lib/falkordb/data by default
[ ] Named volumes recommended (portable, easy to manage) over bind mounts
[ ] AOF persistence: --appendonly yes --appendfsync everysec for durable writes
[ ] RDB snapshots also available as complement to AOF
[ ] ACL persistence: --aclfile on mounted volume — users/passwords/permissions survive restarts
[ ] Password: --requirepass ${FALKORDB_PASSWORD} for authentication
[ ] Maxmemory: --maxmemory 2gb --maxmemory-policy allkeys-lru for memory management
[ ] FALKORDB_ARGS: THREAD_COUNT 8, CACHE_SIZE 50, TIMEOUT_MAX 60000, TIMEOUT_DEFAULT 30000
[ ] QUERY_MEM_CAPACITY: max memory per query in bytes (e.g., 104857600)
[ ] Healthcheck: redis-cli ping (or redis-cli -a password ping), interval 30s, retries 5
[ ] Restart policy: unless-stopped for production
[ ] Logging: json-file driver with max-size 10m, max-file 3 for log rotation
[ ] Networks: dedicated bridge network for isolation
[ ] Separate browser: falkordb/falkordb-browser with FALKORDB_URL and FALKORDB_PASSWORD
[ ] Browser depends_on server in Docker Compose
[ ] Test persistence: create data, stop/start container, query — data should persist
[ ] Clustering: 6 nodes (3 masters + 3 replicas) with --cluster-enabled yes
[ ] Cluster: --cluster-announce-ip and --cluster-announce-port for each node
[ ] Cluster: redis-cli --cluster create with --cluster-replicas 1 --cluster-yes
[ ] Cluster: 16,384 hash slots distributed across masters, each graph on one shard
[ ] Cluster: cluster-aware client computes slot and routes to correct master
[ ] Cluster: MOVED redirect if client guesses wrong shard
[ ] Cluster: 3 masters minimum for fault tolerance
[ ] Cluster: scale with redis-cli --cluster add-node — rebalances hash slots
[ ] GraphRAG-SDK: pip install graphrag-sdk[litellm] (or [litellm,pdf] for PDF)
[ ] GraphRAG-SDK: GraphRAG(connection=ConnectionConfig(host, graph_name), llm, embedder)
[ ] GraphRAG-SDK: rag.ingest(text, document_id) extracts nodes and edges
[ ] GraphRAG-SDK: rag.finalize() — dedup entities, backfill embeddings, build indexes
[ ] GraphRAG-SDK: rag.completion(query) — full RAG with provenance via MENTIONS edges
[ ] GraphRAG-SDK: return_context=True for retrieval trail
[ ] GraphRAG-SDK: apply_changes() for incremental updates (added/modified/deleted)
[ ] GraphRAG-SDK: crash-safe rollforward cutover for incremental updates
[ ] GraphRAG-SDK: schema-guided extraction or open-world
[ ] GraphRAG-SDK: hybrid retrieval — vector, fulltext, Cypher, relationship expansion
[ ] GraphRAG-SDK: multi-tenant via graph_name on connection (per-tenant isolation)
[ ] GraphRAG-SDK: provider-agnostic via LiteLLM (any LLM/embedder)
[ ] Python client: from falkordb import FalkorDB, db.select_graph('name')
[ ] Python client: graph.query('Cypher query') with OpenCypher
[ ] Read FalkorDB vs Neo4j for database comparison
[ ] Read GraphRAG tutorial for GraphRAG frameworks
[ ] Read knowledge graph basics for concepts
[ ] Read Ollama Docker for LLM Docker patterns
[ ] Test: container starts and healthcheck passes
[ ] Test: data persists across container stop/start
[ ] Test: password authentication works
[ ] Test: FalkorDB Browser connects to server
[ ] Test: cluster nodes communicate and shard correctly
[ ] Test: GraphRAG-SDK ingests and queries successfully
[ ] Test: multi-tenant isolation via different graph_name
[ ] Document image choice, volume config, persistence settings, cluster topology, GraphRAG integration

FAQ

How do you deploy FalkorDB with Docker?

Use falkordb/falkordb for dev (with browser) or falkordb/falkordb-server for production. FalkorDB Docker Docs: "Docker run: docker run -d -p 6379:6379 -p 3000:3000 falkordb/falkordb:latest. Docker Compose for flexible deployment. Production: falkordb/falkordb-server (lighter, no browser). Development: falkordb/falkordb (includes browser at port 3000)." Operations: "Use falkordb/falkordb-server for production — excludes browser UI, lighter and more efficient. Use falkordb/falkordb for development when you need built-in browser." Deploy: (1) Dev: docker run -p 6379:6379 -p 3000:3000 falkordb/falkordb. (2) Prod: falkordb/falkordb-server (no browser, lighter). (3) Docker Compose for multi-service. (4) Persistent volume: -v falkordb_data:/var/lib/falkordb/data. (5) AOF: --appendonly yes. (6) Password: --requirepass. (7) FalkorDB Browser at http://localhost:3000.

How do you configure FalkorDB persistence in Docker?

Mount persistent volume to /var/lib/falkordb/data and enable AOF for durability. FalkorDB Persistence: "Create Docker volume: docker volume create falkordb_data. Mount: -v falkordb_data:/var/lib/falkordb/data. FalkorDB stores data in /var/lib/falkordb/data by default. Enable AOF: --appendonly yes. Test: create data, stop/start container, query — data persists. ACL users stored separately — configure --aclfile on mounted volume." Docker Docs: "Production: REDIS_ARGS=--requirepass password --appendonly yes --appendfsync everysec --maxmemory 2gb --maxmemory-policy allkeys-lru. FALKORDB_ARGS=THREAD_COUNT 8 CACHE_SIZE 50 TIMEOUT_MAX 60000." Persistence: (1) Volume: -v falkordb_data:/var/lib/falkordb/data. (2) AOF: --appendonly yes --appendfsync everysec. (3) RDB snapshots also available. (4) Maxmemory: --maxmemory 2gb --maxmemory-policy allkeys-lru. (5) ACL persistence: --aclfile on mounted volume. (6) Named volumes recommended (portable).

How do you set up FalkorDB clustering with Docker?

Launch 6 FalkorDB nodes with cluster-enabled, then create cluster with redis-cli. FalkorDB Cluster: "FalkorDB cluster shards keyspace across master nodes using Redis Cluster hash-slot mechanism (16,384 slots). Each graph is single Redis key, lives on shard whose slot covers hash of its name. Cluster-aware client computes slot and routes to correct master. MOVED redirect if wrong. 3 masters minimum for fault tolerance. Launch 6 nodes: docker run with --cluster-enabled yes --cluster-announce-ip. Create: redis-cli --cluster create node1:6379 ... --cluster-replicas 1. Scale: redis-cli --cluster add-node." Clustering: (1) 6 nodes: 3 masters + 3 replicas. (2) --cluster-enabled yes. (3) redis-cli --cluster create with --cluster-replicas 1. (4) Each graph on one shard. (5) Cluster-aware client routes correctly. (6) Scale: add nodes with --cluster add-node. (7) 16,384 hash slots distributed evenly.

How do you use FalkorDB GraphRAG-SDK with Docker?

Install graphrag-sdk, connect to FalkorDB Docker, ingest documents, query with completion. GraphRAG-SDK Docs: "pip install graphrag-sdk[litellm]. docker run -p 6379:6379 -p 3000:3000 falkordb/falkordb. GraphRAG with ConnectionConfig(host, graph_name), LiteLLM(model), LiteLLMEmbedder(model, dimensions). rag.ingest(text, document_id) — extracts nodes and edges. rag.finalize() — dedup, embeddings, indexes. rag.completion(query) — full RAG with provenance. apply_changes() for incremental updates. Schema-guided extraction or open-world. Hybrid retrieval: vector, fulltext, Cypher, relationship expansion. Cited answers via MENTIONS edges. Multi-tenant via graph_name." Usage: (1) pip install graphrag-sdk[litellm]. (2) Start FalkorDB Docker. (3) GraphRAG(connection, llm, embedder). (4) rag.ingest(text). (5) rag.finalize(). (6) rag.completion(query). (7) Multi-tenant: graph_name per tenant.

What is the complete FalkorDB Docker Compose production setup?

FalkorDB server with persistence, password, health check, logging, and optional browser. Docker Docs: "Complete production: falkordb/falkordb-server with REDIS_ARGS=--requirepass --appendonly yes --appendfsync everysec --maxmemory 2gb --maxmemory-policy allkeys-lru, FALKORDB_ARGS=THREAD_COUNT 8 CACHE_SIZE 50 TIMEOUT_MAX 60000, volumes falkordb_data:/data, healthcheck redis-cli ping, restart unless-stopped, logging json-file max-size 10m. Separate browser: falkordb/falkordb-browser with FALKORDB_URL and FALKORDB_PASSWORD. Networks for isolation." Production setup: (1) falkordb-server: latest image, port 6379, password, AOF, maxmemory, healthcheck. (2) falkordb-browser: port 3000, FALKORDB_URL, depends_on server. (3) Volumes: falkordb_data for persistence. (4) Networks: falkordb-network for isolation. (5) Restart: unless-stopped. (6) Logging: json-file with rotation. (7) Healthcheck: redis-cli ping.

Want a self-hosted AI company brain that does all of this out of the box?
Book a demo →