Quick Start

dependencies {
  implementation("io.crabgraph:crabgraph-embedded:1.0.0")
}

CREATE TABLE movie (
  id      UUID         PRIMARY KEY DEFAULT gen_random_uuid(),
  title   VARCHAR(500) NOT NULL,
  year    INT,
  rating  FLOAT
);

CREATE TABLE acted_in (
  id       UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  from_id  UUID REFERENCES person(id) ON DELETE CASCADE,
  to_id    UUID REFERENCES movie(id)  ON DELETE CASCADE,
  role     VARCHAR(255)  -- edge property
);

-- People who appeared in the same movie
CREATE VIEW co_star AS
  SELECT
    a.from_id               AS from_id,
    b.from_id               AS to_id,
    m.title                 AS movie_title
  FROM  acted_in a
  JOIN  acted_in b ON a.to_id = b.to_id AND a.from_id <> b.from_id
  JOIN  movie m    ON m.id = a.to_id;

// Movies an actor appeared in
g.V().has("person", "name", "Tom Hanks")
  .out("acted_in")
  .values("title")
  .toList()

// Co-stars via the derived view
g.V().has("person", "name", "Tom Hanks")
  .out("co_star")
  .values("name")
  .dedup()
  .toList()

// Shortest path between two people
g.V().has("person", "name", "Alice")
  .repeat(.bothE().otherV().simplePath())
  .until(.has("name", "Bob"))
  .path()
  .limit(1)
  .next()

// Minimal start — schema.sql loaded from classpath root
var crab = CrabGraph.start();

// Builder — full options
var crab = CrabGraph.builder()
  .port(9182)
  .dataDir(Path.of("/var/myapp/graph"))
  .schemaResource("db/schema.sql")
  .start();

// Graceful shutdown
crab.close();

CREATE INDEX idx_person_name ON person(name);
CREATE INDEX idx_person_age  ON person(age);

g.V()                          // all vertices
g.V("some-uuid")              // vertex by ID
g.E()                          // all edges
g.V().hasLabel("person")      // vertices of a specific type
g.V().has("person", "name", "Alice")  // filter by property

// Direct neighbours
g.V().has("person", "name", "Alice").out("knows").values("name")

// N-hop expansion (BFS up to 3 hops)
g.V().has("person", "name", "Alice")
  .repeat(.out("knows").simplePath())
  .times(3)
  .dedup()
  .values("name")

g.V().has("person", "name", "Alice")
  .repeat(.bothE().otherV().simplePath())
  .until(.has("person", "name", "Bob"))
  .path()
  .limit(1)
  .next()

// Movies grouped by year, sorted descending
g.V().hasLabel("movie")
  .group()
  .by("year")
  .by(.values("title").fold())
  .order(Scope.local).by(Column.keys, Order.desc)
  .next()

// Actor with most credits
g.V().hasLabel("person")
  .project("name", "credits")
  .by("name")
  .by(.out("acted_in").count())
  .order().by("credits", Order.desc)
  .limit(10)
  .toList()

// People who know someone older than them
g.V().hasLabel("person").as("a")
  .out("knows").as("b")
  .where("a", P.lt("b")).by("age")
  .select("a").values("name")
  .toList()

<dependency>
  <groupId>io.crabgraph</groupId>
  <artifactId>crabgraph-spring-boot-starter</artifactId>
  <version>1.0.0</version>
</dependency>

crabgraph:
  schema: classpath:schema.sql
  data-dir: /var/myapp/graph   # omit for in-memory
  port: 8182

@Service
public class PersonService {

  private final GraphTraversalSource g;

  public PersonService(CrabGraph crab) {
    this.g = crab.traversal();
  }

  public List<String> friendNames(String name) {
    return g.V().has("person", "name", name)
             .out("knows")
             .values("name")
             .toList();
  }
}

val crab = CrabGraph.start()
val g = crab.traversal()

val friends: List<String> = g.V()
  .has("person", "name", "Alice")
  .out("knows")
  .values<String>("name")
  .toList()

pip install "crabgraph[async]"

import asyncio
from crabgraph import CrabGraph

async def main():
    crab = await CrabGraph.start(schema="./schema.sql")
    g = crab.traversal()

    await g.addV("person").property("name", "Alice").next()

    friends = await g.V().has("person", "name", "Alice")
                        .out("knows")
                        .valueMap("name")
                        .toList()
    print(friends)

asyncio.run(main())

from crabgraph import CrabGraph
from flask import Flask, jsonify

crab = CrabGraph.start(schema="schema.sql", data_dir="/var/graph")
g    = crab.traversal()
app  = Flask(__name__)

@app.route("/people")
def people():
    names = g.V().hasLabel("person").values("name").toList()
    return jsonify(names)

import { CrabGraph, GraphTraversalSource } from 'crabgraph';
import { P, Order } from 'gremlin';

let g: GraphTraversalSource;

export async function initGraph(): Promise<void> {
  const crab = await CrabGraph.start({
    schema: './schema.sql',
    dataDir: process.env.GRAPH_DIR,
  });
  g = crab.traversal();
}

export async function getFriends(name: string): Promise<string[]> {
  return g.V().has('person', 'name', name)
            .out('knows').values('name')
            .toList() as Promise<string[]>;
}

import express from 'express';
import { CrabGraph } from 'crabgraph';

const app = express();

const crab = await CrabGraph.start({ schema: './schema.sql' });
const g    = crab.traversal();

app.get('/people', async (req, res) => {
  const people = await g.V().hasLabel('person').valueMap(true).toList();
  res.json(people);
});

app.listen(3000);

package graph

import (
  "context"
  "fmt"
  crab "io.crabgraph/crabgraph-go"
)

func Example(ctx context.Context) error {
  db, err := crab.Start(ctx, crab.Options{
    SchemaPath: "./schema.sql",
    DataDir:    "/var/graph",    // omit for in-memory
  })
  if err != nil { return err }
  defer db.Close()

  g := db.Traversal()

  _, err = g.AddV("person").
    Property("name", "Alice").
    Property("age", 34).
    Next(ctx)
  if err != nil { return err }

  results, err := g.V().
    HasLabel("person").
    Values("name").
    ToList(ctx)

  fmt.Println(results)
  return err
}

[dependencies]
crabgraph = { version = "1.0", features = ["persistent", "serde"] }

use crabgraph::{CrabGraph, P, Order};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Person {
  name: String,
  age:  i32,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
  let crab = CrabGraph::builder()
    .schema_str(include_str!("../schema.sql"))
    .data_dir("/var/graph")
    .start()
    .await()?;

  let g = crab.traversal();

  // Typed result deserialization
  let people: Vec<Person> = g.v()
    .has_label("person")
    .has("age", P::gt(30))
    .value_map("name", "age")
    .into_vec::<Person>()
    .await()?;

  println!("{people:#?}");
  Ok(())
}

// Before — embedded
var crab = CrabGraph.start();

// After — cloud (same traversal API)
var crab = CrabGraph.cloud()
  .endpoint("wss://my-cluster.crabgraph.io/gremlin")
  .apiKey(System.getenv("CRAB_API_KEY"))
  .connect();

var g = crab.traversal(); // identical from here

// Export from embedded
var embedded = CrabGraph.start();
embedded.export(Path.of("export.graphson"));

// Import into Cloud
var cloud = CrabGraph.cloud().endpoint("wss://...").connect();
cloud.importFrom(Path.of("export.graphson"));

CrabGraph.builder()
  .schemaResource("db/schema.sql")
  .dataDir(Path.of("/var/myapp/graph"))
  .port(8182)
  .queryTimeout(Duration.ofSeconds(60))
  .cacheSize(512 * 1024 * 1024)  // 512 MB
  .logLevel("INFO")
  .metricsPort(9090)
  .start();