xrayGraphDB Documentation

# Pull (or `docker load < xraygraphdb-4.9.4-docker.tar.gz` for the offline tarball)
docker pull xraygraphdb.emtailabs.com/xraygraphdb:v4.9.4

# First run — creates admin/<your-password> on initial boot
docker run -d \
  --name xraygraphdb \
  --restart unless-stopped \
  -p 7689:7689 \
  -v xraygraphdb-data:/var/lib/xraygraphdb \
  -v xraygraphdb-logs:/var/log/xraygraphdb \
  xraygraphdb.emtailabs.com/xraygraphdb:v4.9.4 \
  --license-acknowledge-saved=true \
  --init-admin-user=admin \
  --init-admin-password=YourStrongPassword!23

# Wait ~5s, then confirm the daemon is listening
docker logs xraygraphdb | grep "xrayProtocol listening"
# Expected: "xrayProtocol listening on 0.0.0.0:7689 with 4 workers"

docker stop xraygraphdb && docker rm xraygraphdb
docker run -d \
  --name xraygraphdb \
  --restart unless-stopped \
  -p 7689:7689 \
  -v xraygraphdb-data:/var/lib/xraygraphdb \
  -v xraygraphdb-logs:/var/log/xraygraphdb \
  xraygraphdb.emtailabs.com/xraygraphdb:v4.9.4 \
  --license-acknowledge-saved=true

docker run -d \
  --name xraygraphdb \
  -p 7689:7689 \
  -v xraygraphdb-data:/var/lib/xraygraphdb \
  -v /path/to/license.xglicense:/etc/xraygraphdb/license.xglicense:ro \
  xraygraphdb.emtailabs.com/xraygraphdb:v4.9.4 \
  --license-acknowledge-saved=true

docker logs xraygraphdb | grep "License loaded"
# Expected: "License loaded: xg-ent-... tier=enterprise org=..."

services:
  xraygraphdb:
    image: xraygraphdb.emtailabs.com/xraygraphdb:v4.9.4
    restart: unless-stopped
    ports:
      - "7689:7689"
    volumes:
      - xraygraphdb-data:/var/lib/xraygraphdb
      - xraygraphdb-logs:/var/log/xraygraphdb
      # Optional: Enterprise license
      # - ./license.xglicense:/etc/xraygraphdb/license.xglicense:ro
    command:
      - --license-acknowledge-saved=true
      # --- FIRST RUN ONLY: uncomment for the first `docker compose up`,
      # --- then comment back out and `docker compose up -d --force-recreate`.
      # - --init-admin-user=admin
      # - --init-admin-password=YourStrongPassword!23

volumes:
  xraygraphdb-data:
  xraygraphdb-logs:

docker compose up -d
docker compose logs -f xraygraphdb | grep "xrayProtocol listening"

# Container status
docker ps --filter name=xraygraphdb

# Daemon ready check — xrayProtocol on 7689 (Bolt is OFF by default; opt-in via --bolt-server-name)
docker logs xraygraphdb | grep "xrayProtocol listening"
# Expected: "xrayProtocol listening on 0.0.0.0:7689 with 4 workers"

# Test connection (Python xray_protocol_client; HELLO must carry a database name)
python3 -c 'import xray_protocol_client as xg
conn = xg.connect(host="localhost", port=7689,
                  auth_token="admin:YourStrongPassword!23",
                  database="xraygraphdb")
print(conn.execute_query("MATCH (n) RETURN count(n) AS n_count"))'

# 1. Download
wget https://xraygraphdb.emtailabs.com/downloads/xraygraphdb_4.9.4_amd64.deb

# 2. Install — use `apt install -f` so apt auto-resolves the libgdal34t64 + python3 deps.
#    `dpkg -i` directly will FAIL the first time with "depends on libgdal34t64; however ...".
sudo apt install -f ./xraygraphdb_4.9.4_amd64.deb

wget https://xraygraphdb.emtailabs.com/downloads/xraygraphdb-4.9.4-linux-x86_64.tar.gz
tar xzf xraygraphdb-4.9.4-linux-x86_64.tar.gz
cd xraygraphdb-4.9.4-linux-x86_64
sudo ./install.sh

sudo mkdir -p /etc/systemd/system/xraygraphdb.service.d
sudo tee /etc/systemd/system/xraygraphdb.service.d/local.conf >/dev/null <<'EOF'
[Service]
ExecStart=
ExecStart=/usr/lib/xraygraphdb/xraygraphdb \
    --data-directory=/var/lib/xraygraphdb \
    --bolt-port=7687 \
    --xray-port=7689 \
    --storage-properties-on-edges=true \
    --log-level=WARNING \
    --license-acknowledge-saved=true \
    --bolt_listen_mode=off
EOF

sudo systemctl daemon-reload
sudo systemctl start xraygraphdb
sudo systemctl status xraygraphdb
ss -tlnp | grep :7689     # xrayProtocol

# Download macOS binary (Apple Silicon or Intel)
curl -LO https://releases.emtailabs.com/xraygraphdb/xraygraphdb-v4.9.4-macos-arm64.tar.gz

# Extract and run
tar xzf xraygraphdb-v4.9.4-macos-arm64.tar.gz
cd xraygraphdb-v4.9.4
./bin/xraygraphdb-wrapper

sudo xraygraphdb-bootstrap-admin

# Right way — daemon can read it:
sudo mkdir -p /var/lib/xraygraphdb/import
sudo mv ~/com-friendster.ungraph.txt /var/lib/xraygraphdb/import/
sudo chown -R xraygraphdb:xraygraphdb /var/lib/xraygraphdb/import

# Then in your bench/import script:
client.bulk_import_file("/var/lib/xraygraphdb/import/com-friendster.ungraph.txt")

# Wrong way — daemon's PrivateTmp namespace makes this invisible:
#   client.bulk_import_file("/tmp/com-friendster.ungraph.txt")    ← returns 0/0 in 1s

[Service]
ReadWritePaths=/data

-- Connect AS the user who should own this database, then:
CREATE DATABASE myapp;

-- Confirm it exists and switch to it
SHOW DATABASES;
USE DATABASE myapp;

-- Destructive: this deletes the data. Re-import afterwards.
DROP DATABASE myapp;

-- Now reconnect AS the intended owner and create it again
CREATE DATABASE myapp;

CREATE DATABASE analytics WITH
  storage_mode = 'mmap',        -- overrides the server's --storage-engine default
  mmap_reservation_gb = '64',   -- per-database mmap ceiling, fixed when the files open
  wal = 'true',
  snapshot_interval = '300';

REGISTER INSTANCE inst_1 WITH CONFIG {
  "bolt_server":        "10.0.0.11:7687",
  "management_server":  "10.0.0.11:37801",
  "replication_server": "10.0.0.11:37811"
};

UNREGISTER INSTANCE inst_1;

SHOW INSTANCES;

pip install neo4j

from neo4j import GraphDatabase

driver = GraphDatabase.driver(
    "bolt://localhost:7687",
    auth=("admin", "<your-password>")
)

with driver.session() as session:
    # Create a node
    session.run(
        "CREATE (n:Person {name: $name, age: $age})",
        name="Alice", age=30
    )

    # Read it back
    result = session.run(
        "MATCH (n:Person {name: $name}) RETURN n.name, n.age",
        name="Alice"
    )
    record = result.single()
    print(record["n.name"], record["n.age"])
    # Output: Alice 30

driver.close()

npm install neo4j-driver

const neo4j = require('neo4j-driver');

const driver = neo4j.driver(
  'bolt://localhost:7687',
  neo4j.auth.basic('admin', '<your-password>')
);

const session = driver.session();

try {
  // Create a node
  await session.run(
    'CREATE (n:Person {name: $name, age: $age})',
    { name: 'Bob', age: 25 }
  );

  // Read it back
  const result = await session.run(
    'MATCH (n:Person {name: $name}) RETURN n',
    { name: 'Bob' }
  );

  console.log(result.records[0].get('n').properties);
} finally {
  await session.close();
  await driver.close();
}

<!-- Maven dependency -->
<dependency>
  <groupId>org.neo4j.driver</groupId>
  <artifactId>neo4j-java-driver</artifactId>
  <version>5.x</version>
</dependency>

import org.neo4j.driver.*;

public class XRayExample {
    public static void main(String[] args) {
        var driver = GraphDatabase.driver(
            "bolt://localhost:7687",
            AuthTokens.basic("admin", "<your-password>")
        );

        try (var session = driver.session()) {
            session.run(
                "CREATE (n:Person {name: $name})",
                Values.parameters("name", "Carol")
            );

            var result = session.run(
                "MATCH (n:Person) RETURN n.name"
            );

            while (result.hasNext()) {
                System.out.println(result.next().get("n.name").asString());
            }
        }
        driver.close();
    }
}

go get github.com/neo4j/neo4j-go-driver/v5

package main

import (
    "context"
    "fmt"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
)

func main() {
    ctx := context.Background()

    driver, err := neo4j.NewDriverWithContext(
        "bolt://localhost:7687",
        neo4j.BasicAuth("admin", "<your-password>", ""),
    )
    if err != nil { panic(err) }
    defer driver.Close(ctx)

    session := driver.NewSession(ctx, neo4j.SessionConfig{})
    defer session.Close(ctx)

    _, err = session.Run(ctx,
        "CREATE (n:Person {name: $name})",
        map[string]any{"name": "Dave"},
    )
    if err != nil { panic(err) }

    result, err := session.Run(ctx,
        "MATCH (n:Person) RETURN n.name", nil,
    )
    if err != nil { panic(err) }

    for result.Next(ctx) {
        fmt.Println(result.Record().Values[0])
    }
}

dotnet add package Neo4j.Driver

using Neo4j.Driver;

var driver = GraphDatabase.Driver(
    "bolt://localhost:7687",
    AuthTokens.Basic("admin", "<your-password>")
);

await using var session = driver.AsyncSession();

await session.RunAsync(
    "CREATE (n:Person {name: $name})",
    new { name = "Eve" }
);

var result = await session.RunAsync(
    "MATCH (n:Person) RETURN n.name"
);

var records = await result.ToListAsync();
foreach (var record in records)
{
    Console.WriteLine(record["n.name"].As<string>());
}

await driver.DisposeAsync();

// Step 1: Create some nodes
CREATE (alice:Person {name: "Alice", age: 30})
CREATE (bob:Person {name: "Bob", age: 25})
CREATE (carol:Person {name: "Carol", age: 35})
CREATE (proj:Project {name: "xrayGraphDB"})
RETURN alice, bob, carol, proj;

// Step 2: Create relationships
MATCH (a:Person {name: "Alice"}), (b:Person {name: "Bob"})
CREATE (a)-[:KNOWS]->(b)
RETURN a, b;

MATCH (a:Person {name: "Alice"}), (p:Project {name: "xrayGraphDB"})
CREATE (a)-[:WORKS_ON {role: "lead"}]->(p)
RETURN a, p;

MATCH (b:Person {name: "Bob"}), (p:Project {name: "xrayGraphDB"})
CREATE (b)-[:WORKS_ON {role: "contributor"}]->(p)
RETURN b, p;

// Step 3: Query the graph
MATCH (p:Person)-[:WORKS_ON]->(proj:Project)
RETURN p.name, proj.name;

// Step 4: Update properties
MATCH (a:Person {name: "Alice"})
SET a.email = "alice@example.com"
RETURN a;

// Step 5: Clean up
MATCH (n) DETACH DELETE n;

// Match all nodes with a specific label
MATCH (n:Person)
RETURN n;

// Match a relationship pattern
MATCH (a:Person)-[:KNOWS]->(b:Person)
RETURN a.name, b.name;

// Match with relationship variable
MATCH (a:Person)-[r:WORKS_ON]->(p:Project)
RETURN a.name, r.role, p.name;

// Match any direction
MATCH (a:Person)-[:KNOWS]-(b:Person)
RETURN a.name, b.name;

// Match with multiple labels
MATCH (n:Person:Employee)
RETURN n;

// Comparison operators
MATCH (n:Person)
WHERE n.age > 25 AND n.age <= 40
RETURN n.name, n.age;

// String matching
MATCH (n:Person)
WHERE n.name STARTS WITH "A"
RETURN n;

// Regular expression
MATCH (n:Person)
WHERE n.email =~ ".*@example\\.com"
RETURN n;

// Null checks
MATCH (n:Person)
WHERE n.email IS NOT NULL
RETURN n;

// IN list
MATCH (n:Person)
WHERE n.name IN ["Alice", "Bob", "Carol"]
RETURN n;

// Pattern predicates (exists)
MATCH (n:Person)
WHERE (n)-[:WORKS_ON]->()
RETURN n.name;

// Return specific properties
MATCH (n:Person)
RETURN n.name, n.age;

// Alias with AS
MATCH (n:Person)
RETURN n.name AS person_name, n.age AS years;

// Return all properties as a map
MATCH (n:Person)
RETURN properties(n);

// Return distinct values
MATCH (n:Person)-[:WORKS_ON]->(p:Project)
RETURN DISTINCT p.name;

// Expressions in RETURN
MATCH (n:Person)
RETURN n.name, n.age * 12 AS age_in_months;

// Order by a property
MATCH (n:Person)
RETURN n.name, n.age
ORDER BY n.age DESC;

// Limit results
MATCH (n:Person)
RETURN n.name
ORDER BY n.name
LIMIT 10;

// Pagination with SKIP and LIMIT
MATCH (n:Person)
RETURN n.name
ORDER BY n.name
SKIP 20
LIMIT 10;

// Multiple sort keys
MATCH (n:Person)
RETURN n.name, n.age
ORDER BY n.age DESC, n.name ASC;

// Filter intermediate results
MATCH (p:Person)-[:WORKS_ON]->(proj:Project)
WITH proj, count(p) AS team_size
WHERE team_size > 3
RETURN proj.name, team_size
ORDER BY team_size DESC;

// Chain queries
MATCH (n:Person)
WITH n
ORDER BY n.age DESC
LIMIT 5
MATCH (n)-[:KNOWS]->(friend)
RETURN n.name, collect(friend.name) AS friends;

// Expand a list
UNWIND [1, 2, 3] AS x
RETURN x;

// Bulk create from parameters
UNWIND $people AS person
CREATE (n:Person {name: person.name, age: person.age});

// Combine with MATCH
UNWIND ["Alice", "Bob"] AS name
MATCH (n:Person {name: name})
RETURN n;

// Return all people, even those without projects
MATCH (p:Person)
OPTIONAL MATCH (p)-[:WORKS_ON]->(proj:Project)
RETURN p.name, proj.name;

// Create a single node
CREATE (n:Person {name: "Frank", age: 28})
RETURN n;

// Create multiple nodes
CREATE (a:Person {name: "Grace"}),
       (b:Person {name: "Hank"});

// Create a node with multiple labels
CREATE (n:Person:Developer {name: "Ivy"});

// Create a relationship between existing nodes
MATCH (a:Person {name: "Grace"}), (b:Person {name: "Hank"})
CREATE (a)-[:KNOWS {since: 2024}]->(b)
RETURN a, b;

// Create a full path in one statement
CREATE (a:Module {name: "auth"})-[:IMPORTS]->(b:Module {name: "crypto"})
RETURN a, b;

// Merge a node (create if not exists)
MERGE (n:Person {name: "Alice"})
ON CREATE SET n.created = timestamp()
ON MATCH SET n.lastSeen = timestamp()
RETURN n;

// Merge a relationship
MATCH (a:Person {name: "Alice"}), (b:Person {name: "Bob"})
MERGE (a)-[r:KNOWS]->(b)
ON CREATE SET r.since = 2024
RETURN r;

// Set a property
MATCH (n:Person {name: "Alice"})
SET n.age = 31
RETURN n;

// Set multiple properties
MATCH (n:Person {name: "Alice"})
SET n.age = 31, n.email = "alice@example.com"
RETURN n;

// Replace all properties with a map
MATCH (n:Person {name: "Alice"})
SET n = {name: "Alice", age: 31, active: true}
RETURN n;

// Merge properties (add without removing existing)
MATCH (n:Person {name: "Alice"})
SET n += {department: "engineering"}
RETURN n;

// Add a label
MATCH (n:Person {name: "Alice"})
SET n:Employee
RETURN n;

// Remove a property
MATCH (n:Person {name: "Alice"})
REMOVE n.email
RETURN n;

// Remove a label
MATCH (n:Person:Employee {name: "Alice"})
REMOVE n:Employee
RETURN labels(n);

// Delete a relationship
MATCH (a:Person)-[r:KNOWS]->(b:Person)
WHERE a.name = "Alice" AND b.name = "Bob"
DELETE r;

// Delete a node (must have no relationships)
MATCH (n:Person {name: "Frank"})
DELETE n;

// Detach delete (node + all relationships)
MATCH (n:Person {name: "Alice"})
DETACH DELETE n;

// Delete all nodes and relationships in the database
MATCH (n) DETACH DELETE n;

// Paths of exactly 2 hops
MATCH (a:Person)-[:KNOWS*2]->(c:Person)
RETURN a.name, c.name;

// Paths of 1 to 5 hops
MATCH (a:Person)-[:KNOWS*1..5]->(c:Person)
RETURN a.name, c.name;

// Paths of any length (use with caution)
MATCH (a:Person {name: "Alice"})-[:KNOWS*]->(c:Person)
RETURN DISTINCT c.name;

// Capture the path
MATCH path = (a:Person {name: "Alice"})-[:KNOWS*1..3]->(c:Person)
RETURN path, length(path) AS hops;

// Find one shortest path
MATCH (a:Person {name: "Alice"}),
      (b:Person {name: "Eve"})
MATCH p = shortestPath((a)-[*..10]-(b))
RETURN p, length(p) AS hops;

// Find all shortest paths (same length)
MATCH (a:Person {name: "Alice"}),
      (b:Person {name: "Eve"})
MATCH p = allShortestPaths((a)-[*..10]-(b))
RETURN p;

// With relationship type filter
MATCH (a:Person {name: "Alice"}),
      (b:Person {name: "Eve"})
MATCH p = shortestPath((a)-[:KNOWS|WORKS_WITH*..10]-(b))
RETURN p;

// BFS with upper bound
MATCH (start:Person {name: "Alice"})
MATCH path = (start)-[:KNOWS BFS]->(target)
RETURN target.name, length(path) AS distance
ORDER BY distance;

// Count
MATCH (n:Person)
RETURN count(n) AS total_people;

// Group and count
MATCH (p:Person)-[:WORKS_ON]->(proj:Project)
RETURN proj.name, count(p) AS team_size
ORDER BY team_size DESC;

// Sum, average, min, max
MATCH (n:Person)
RETURN
  sum(n.age) AS total_age,
  avg(n.age) AS avg_age,
  min(n.age) AS youngest,
  max(n.age) AS oldest;

// Collect into a list
MATCH (p:Person)-[:WORKS_ON]->(proj:Project)
RETURN proj.name, collect(p.name) AS members;

// Standard deviation and percentile
MATCH (n:Person)
RETURN
  stDev(n.age) AS std_dev,
  percentileCont(n.age, 0.5) AS median;

// Create a label-property index
CREATE INDEX ON :Person(name);

// Neo4j-compatible named index syntax
CREATE INDEX person_name_idx
FOR (n:Person)
ON (n.name);

// Composite index
CREATE INDEX ON :Person(name, age);

// Drop an index
DROP INDEX ON :Person(name);

// Unique constraint
CREATE CONSTRAINT ON (n:Person) ASSERT n.email IS UNIQUE;

// Existence constraint
CREATE CONSTRAINT ON (n:Person) ASSERT EXISTS (n.name);

// Show index info
SHOW INDEX INFO;

// List all constraints
SHOW CONSTRAINT INFO;

with driver.session() as session:
    tx = session.begin_transaction()
    try:
        tx.run("CREATE (a:Account {id: $id, balance: $bal})",
               id="A001", bal=1000)
        tx.run("CREATE (a:Account {id: $id, balance: $bal})",
               id="A002", bal=500)
        tx.commit()
    except Exception:
        tx.rollback()
        raise

// Explicit transaction commands (Bolt protocol)
BEGIN;
CREATE (n:Temp {data: "test"});
COMMIT;

// Or rollback
BEGIN;
CREATE (n:Temp {data: "test"});
ROLLBACK;

// Set context to all Function nodes
SET GFQL_CONTEXT label='Function';

// Set context with edge filter
SET GFQL_CONTEXT label='Module', edge_type='IMPORTS';

// Set context with property filter
SET GFQL_CONTEXT label='Person', WHERE age > 25;

// Find high-complexity functions and their callees
chain()
  .n(label='Function')
  .filter(complexity > 10)
  .e_forward(type='CALLS')
  .select('source.name', 'target.name');

// Multi-hop traversal
chain()
  .n(label='Module', name='auth')
  .hop(edge_type='IMPORTS', depth=3)
  .select('name', '_hop_depth');

// Aggregate by module
chain()
  .n(label='Function')
  .aggregate(by='module', count='name', avg_complexity='complexity');