A graph database written in rust.

IndraDB consists of a server and an underlying library. Most users would use the server, which is available via releases as pre-compiled binaries. But if you're a rust developer that wants to embed a graph database directly in your application, you can use the library.

IndraDB's original design was heavily inspired by TAO, facebook's graph datastore. In particular, IndraDB emphasizes simplicity of implementation and query semantics, and is similarly designed with the assumption that it may be representing a graph large enough that full graph processing is not possible. Over time, richer query semantics and other features have been added to IndraDB, so it can no longer be called TAO-like, although we try to stay true to some of those original goals.

For more details, see the homepage. See also a complete demo of IndraDB for browsing the wikipedia article link graph.

• Directed and typed graphs.
• JSON-based properties tied to vertices and edges.
• Queries with multiple hops, and queries on indexed properties.
• Cross-language support via gRPC, or direct embedding as a library.
• Pluggable underlying datastores, with several built-in datastores. Postgresql and sled are available separately.
• Written in rust! High performance, no GC pauses, and a higher degree of safety.

IndraDB offers a variety ways to work with it: as a server with cross-language support, as a rust library, and via CLI. What follows are a few examples of each use case.

The server uses gRPC to facilitate cross-language support. gRPC supports many languages; see the official list, though many more are unofficially supported as well. We have official bindings available for python and rust. These examples will require you to have a running server, e.g. to start an in-memory server, simply run indradb-server.

Python bindings are available here and published to pypi as indradb. An example:

import indradb
import uuid

# Connect to the server and make sure it's up
client = indradb.Client("localhost:27615")
client.ping()

# Create a couple of vertices
out_v = indradb.Vertex(uuid.uuid4(), "person")
in_v = indradb.Vertex(uuid.uuid4(), "movie")
client.create_vertex(out_v)
client.create_vertex(in_v)

# Add an edge between the vertices
edge = indradb.Edge(out_v.id, "bar", in_v.id)
client.create_edge(edge)

# Query for the edge
results = list(client.get(indradb.SpecificEdgeQuery(edge))
print(results)

For further reference, see the docs and python bindings tests.

The gRPC bindings library is available as indradb-proto. An example:

use indradb;
use indradb_proto as proto;

// Connect to the server and make sure it's up
let mut client = proto::Client::new("grpc://127.0.0.1:27615".try_into()?).await?;
client.ping().await?;

// Create a couple of vertices
let out_v = indradb::Vertex::new(indradb::Identifier::new("person")?);
let in_v = indradb::Vertex::new(indradb::Identifier::new("movie")?);
client.create_vertex(&out_v).await?;
client.create_vertex(&in_v).await?;

// Add an edge between the vertices
let edge = indradb::Edge::new(out_v.id, indradb::Identifier::new("likes")?, in_v.id);
client.create_edge(&edge).await?;

// Query for the edge
let output: Vec<indradb::QueryOutputValue> = client.get(indradb::SpecificEdgeQuery::single(edge.clone())).await?;
// Convenience function to extract out the edges from the query results
let e = indradb::util::extract_edges(output).unwrap();
assert_eq!(e.len(), 1);
assert_eq!(edge, e[0]);

The rust gRPC bindings library is built to closely mirror the rust library. But if you're using 100% rust, and don't need a server, you can skip all the gRPC rigmarole and just use the rust library directly. For further reference, see the docs and the wikipedia indexing example, which heavily relies on indradb-proto.

If you're looking to contribute, adding bindings for your favorite language is a great way to start! The gRPC/protobuf definitions are here.

Add IndraDB to your Cargo.toml:

indradb-lib = { version = "*", features = ["rocksdb-datastore"] }

(You might want to pin the version, or not include the RocksDB datastore and only support in-memory.)

Here's a brief example:

use indradb;

// Create an in-memory datastore
let db: indradb::Database<indradb::MemoryDatastore> = indradb::MemoryDatastore::new_db();

// Create a couple of vertices
let out_v = indradb::Vertex::new(indradb::Identifier::new("person")?);
let in_v = indradb::Vertex::new(indradb::Identifier::new("movie")?);
db.create_vertex(&out_v)?;
db.create_vertex(&in_v)?;

// Add an edge between the vertices
let edge = indradb::Edge::new(out_v.id, indradb::Identifier::new("likes")?, in_v.id);
db.create_edge(&edge)?;

// Query for the edge
let output: Vec<indradb::QueryOutputValue> = db.get(indradb::SpecificEdgeQuery::single(edge.clone()))?;
// Convenience function to extract out the edges from the query results
let e = indradb::util::extract_edges(output).unwrap();
assert_eq!(e.len(), 1);
assert_eq!(edge, e[0]);

For further reference, see the docs and library tests.

The CLI interacts with a running server.

First start the server: indradb-server.

Then, e.g. count the number of vertices: indradb-client grpc://127.0.0.1:27615 count vertex.

We offer pre-compiled releases for linux and macOS.

• Download the latest release for your platform.
• Add the binaries to your PATH.
• Start the server: indradb-server

This should start the default datastore.

To build and install from source:

• Install rust. IndraDB should work with any of the rust variants (stable, nightly, beta.)
• Make sure you have gcc 5+ and the protobuf toolchain installed.
• Clone the repo: git clone git@github.com:indradb/indradb.git.
• Build/install it: cargo install.

If you want to run IndraDB in docker, follow the below instructions.

Build the image for the server:

DOCKER_BUILDKIT=1 docker build --target server -t indradb-server .

Run the server:

docker run --network host --rm indradb-server -a 0.0.0.0:27615

Build the image for the client:

DOCKER_BUILDKIT=1 docker build --target client -t indradb-client .

Run the client:

docker run --network host --rm indradb-client grpc://localhost:27615 ping

IndraDB offers several different datastores with trade-offs in durability, transaction capabilities, and performance.

By default, IndraDB starts a datastore that stores all values in-memory. This is the fastest implementation, but there's no support for graphs larger than what can fit in-memory, and data is only persisted to disk when explicitly requested.

If you want to use the standard datastore without support for persistence, don't pass a subcommand; e.g.:

indradb-server [options]

If you want to use the standard datastore but persist to disk:

indradb-server memory --persist-path=[/path/to/memory/image]

You'll need to explicitly call Sync() when you want to save the graph.

If you want to use the rocksdb-backed datastore, use the rocksdb subcommand; e.g.:

indradb-server rocksdb [/path/to/rocksdb.rdb] [options]

It's possible to develop other datastores implementations in separate crates, since the IndraDB exposes the necessary traits to implement:

• Postgres is available through indradb-postgres.
• Sled is available through indradb-sled.

The IndraDB server includes support for plugins to extend functionality available to clients. Plugins are loaded via dynamically linked libraries.

See the hello world plugin and naive vertex plugin for demonstrations of how to author plugins.

To include plugins, see the --plugins argument for indradb-server, e.g. indradb-server --plugins=plugins/*.so. They are then callable via the gRPC ExecutePlugin function.

First follow the source building instructions above.

Use make test to run the test suite. Note that this will run the full test suite across the entire workspace, including tests for all datastore implementations. You can filter which tests run via the TEST_NAME environment variable. e.g. TEST_NAME=create_vertex make test will run tests with create_vertex in the name across all datastore implementations. All unit tests will run in CI.

Microbenchmarks can be run via make bench.

A fuzzer is available, ensuring the the RocksDB and in-memory datastores operate identically. Run it via make fuzz.

Lint and formatting checks can be run via make check. Equivalent checks will be run in CI.