HelixDB/helix-db

HelixDB: a graph-vector database for knowledge graphs and AI memory. Built from scratch in Rust.

website | docs | discord | X/twitter

HelixDB is a database that makes it easy to build all the components needed for AI applications in a single platform.

You don't need a separate application DB, relational DB, vector DB, graph DB, or application layers to manage the multiple storage locations. HelixDB gives your agents federated access to company data, for memory, company brains, and applications.

Helix primarily operates with a graph + vector data model, but it also supports KV, documents, and relational data.

Getting Started

1. Install the CLI

The Helix CLI runs and manages local instances and talks to Helix Cloud.

macOS and Linux:

curl -sSL "https://install.helix-db.com" | bash

Windows PowerShell:

irm https://raw.githubusercontent.com/HelixDB/helix-db/main/crates/cli/install.ps1 | iex

Already installed? Update to the latest version with helix update.

2. The quickest path — helix chef

helix chef is an interactive, one-shot bootstrapper. It installs the HelixDB query skills and docs MCP, scaffolds a project, starts a local instance, seeds some example data, and writes a HELIX_CHEF_PROMPT.md. It detects supported agents in this order: Claude Code → OpenAI Codex → OpenCode → Cursor Agent. When one is available, it can hand off and build a working app — frontend and all — from a one-line description of what you want.

helix chef

That's it — no flags. Answer "what do you want to build?" and follow the prompts.

3. Manual local setup

If you would rather wire things up yourself, follow the canonical local quickstart. It uses the exact files and dev instance generated by the current CLI.

Writing queries with the SDKs

Queries are authored with the Rust, TypeScript, Go, or Python DSL and sent straight to a running instance through POST /v2/query — no build or deploy step. The SDKs produce the same JSON AST. The examples below talk to a local instance on http://localhost:6969 (the default helix start dev port). See the Querying Guide for the full builder catalog and query wire format.

| SDK | Package | Current release | Setup guide | |-----|---------|-----------------|-------------| | Rust | helix-db | 3.0.0 | Rust setup | | TypeScript | @helix-db/helix-db | 3.0.4 | TypeScript setup | | Python | helix-db | 0.3.4 | Python setup | | Go | github.com/helixdb/helix-db/sdks/go | v0.3.1 | Go setup |

Rust

Install the crate (published as helix-db, imported as helix_db):

cargo init && cargo add helix-db@3.0.0 tokio sonic-rs

Define queries as #[query] functions, then run them directly through the client:

use helix_db::Client;
use helix_db::dsl::prelude::*;
[query]
pub fn add_user(name: String) -> WriteBatch {
    write_batch()
        .var_as(
            "user",
            g().add_n("User", vec![("name", name)])
                .value_map(None::>),
        )
        .returning(["user"])
}
[query]
pub fn get_user(name: String) -> ReadBatch {
    read_batch()
        .var_as(
            "user",
            g().n_with_label("User")
                .where_(Predicate::eq("name", name))
                .value_map(None::>),
        )
        .returning(["user"])
}
[tokio::main]
async fn main() -> Result<(), Box> {
    let client = Client::new(None)?; // defaults to http://localhost:6969
// add user — #[query] helpers return Result
    let new_user: sonic_rs::Value = client
        .query(add_user("John Doe".to_string())?)
        .send()
        .await?;
    println!("new user: {:#}", sonic_rs::to_string_pretty(&new_user)?);
// get user
    let user: sonic_rs::Value = client
        .query(get_user("John Doe".to_string())?)
        .send()
        .await?;
    println!("user: {:#}", sonic_rs::to_string_pretty(&user)?);
    Ok(())
}

TypeScript

Install the package (Node.js 20+):

npm init -y && npm install @helix-db/helix-db@3.0.4

Define your queries as functions, then POST them to the running instance:

import {
  Predicate, PropertyInput, PropertyProjection,
  defineParams, g, param, readBatch, writeBatch,
} from "@helix-db/helix-db";
const addUserParams = defineParams({ name: param.string() });
function addUser(p = addUserParams) {
  return writeBatch()
    .varAs("user",
      g().addN("User", { name: PropertyInput.param("name") })
        .project([PropertyProjection.new("name")]),
    )
    .returning(["user"]);
}
const getUserParams = defineParams({ name: param.string() });
function getUser(p = getUserParams) {
  return readBatch()
    .varAs("user",
      g().nWithLabel("User")
        .where(Predicate.eqParam("name", "name"))
        .project([PropertyProjection.new("name")]),
    )
    .returning(["user"]);
}
const HELIX_URL = "http://localhost:6969/v2/query";
// add user
const newUser = await fetch(HELIX_URL, {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: addUser().toQueryJson(addUserParams, { name: "John Doe" }),
}).then((r) => r.json());
console.log("new user:", newUser);
// get user
const user = await fetch(HELIX_URL, {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: getUser().toQueryJson(getUserParams, { name: "John Doe" }),
}).then((r) => r.json());
console.log("user:", user);

Python

Install the published PyPI package:

python -m pip install helix-db==0.3.4

Build requests with snake_case builders, then send them with the client:

from helixdb import Client, Predicate, g, param, define_params, read_batch, write_batch
add_user_params = define_params({"name": param.string()})
add_user = (
    write_batch()
    .var_as("user", g().add_n("User", {"name": add_user_params.name}))
    .returning(["user"])
)
get_user_params = define_params({"name": param.string()})
get_user = (
    read_batch()
    .var_as(
        "user",
        g()
        .n_with_label("User")
        .where(Predicate.eq("name", get_user_params.name))
        .value_map(["name"]),
    )
    .returning(["user"])
)
client = Client("http://localhost:6969")
new_user = client.query(
    add_user.to_query_request(add_user_params, {"name": "John Doe"})
)
print("new user:", new_user)
user = client.query(
    get_user.to_query_request(get_user_params, {"name": "John Doe"})
)
print("user:", user)

Go

Install the released Go module:

go mod init example.com/my-helix-app
go get github.com/helixdb/helix-db/sdks/go@v0.3.1

Build a request with ordinary Go functions, then execute it with the client:

package main
import (
    "context"
    "fmt"
    "log"
helix "github.com/helixdb/helix-db/sdks/go"
)
func getUsers() helix.Request {
    return helix.ReadQuery("get_users").
        VarAs("users", helix.G().NWithLabel("User").ValueMap("$id", "name")).
        Returning("users")
}
func main() {
    client, err := helix.NewClient("http://localhost:6969")
    if err != nil {
        log.Fatal(err)
    }
var response map[string]any
    if err := client.Exec(context.Background(), getUsers(), &response); err != nil {
        log.Fatal(err)
    }
    fmt.Println(response)
}

Version names

• HelixDB v3 is the current product and SDK generation.
• Helix CLI 3.x is the independently released command-line client. Check its exact version with helix --version.
• POST /v2/query is the current HTTP wire endpoint. Its v2 path does not mean HelixDB v2 or CLI v2.

HelixDB Cloud

HelixDB Cloud is an object-storage-backed deployment with integrated vector and full-text search, full ACID transactions, a single writer with auto-scaling reader nodes, and high availability (3+ gateways and DB nodes). The CLI uses a WorkOS session for Cloud control-plane and brokered query operations:

helix auth login
helix workspace list
helix project link  --workspace 
helix init cloud --database tenant: --project  --workspace 
helix query production --file examples/request.json

Cloud queries go through the authenticated backend broker. Application keys returned by tenant or key creation are for direct gateway clients; the CLI displays them once and never stores or uses them.

Commercial Support

HelixDB Cloud

HelixDB is available as a distributed, high-availability, managed service. If you're interested in using Helix's managed service, go to our website to get started or contact us to talk with a founder.

Docs & Community

• 📚 Documentation · Querying Guide
• 💬 Discord
• 🐦 X / Twitter

Just Use Helix.