These docs cover Strata 0.9.0-preview.1.It is a preview, and the API can still change before 1.0.

Installation

Strata comes as NuGet packages on nuget.org, as crates on crates.io, and as a strata command-line tool on GitHub. All of them share one version number and are released together. These docs cover 0.9.0-preview.1.

The .NET 10 SDK. The packages target net10.0.

Rust 1.88 or later. The crates use the 2024 edition, and the Redis client they depend on needs 1.88.
The tokio runtime. Running a graph is async.

You don’t need an account, a token or an extra package source. You don’t need a database to start either: Strata has in-memory stores for development and tests. When you’re ready for durable storage, the SQLite, Postgres and Redis stores are in the same packages and crates. Choose a store compares them.

Add the packages to a .NET project

The packages are on nuget.org, which every .NET project already uses.

Pick a package

Package	What it contains
`Datalium.Strata.Hosting`	`AddStrata()` for the .NET Generic Host: registering graphs and stores, settings from configuration, background drivers, health checks and OpenTelemetry. Brings all the packages below.
`Datalium.Strata`	The engine: graphs, validation, streaming, interrupts, retries and the `[StrataTool]` source generator.
`Datalium.Strata.Storage`	Checkpoint and history stores: in-memory, SQLite, Postgres and Redis. Also long-term memory stores for Postgres, SQLite and Redis.
`Datalium.Strata.Cloud`	For the Strata Cloud private beta: the Cloud checkpoint store, its decisions client and a decision worker.
`Datalium.Strata.AI`	Model calls, agents, model routes, embeddings and long-term memory, on any `IChatClient` from Microsoft.Extensions.AI.

Most applications reference Datalium.Strata.Hosting alone. It brings the engine, the stores, the Cloud client and the AI package, and the source generator reaches your project through it, so [StrataTool] works with no extra reference.

To keep the dependencies small, for example in a library, reference Datalium.Strata and the packages you use instead. To run a graph you need a checkpoint store, so you need Datalium.Strata.Storage or a store of your own.

Add the reference

Preview versions aren’t picked by default, so give the version (or pass --prerelease):

dotnet add package Datalium.Strata.Hosting --version 0.9.0-preview.1

This adds the reference to your project file:

<PackageReference Include="Datalium.Strata.Hosting" Version="0.9.0-preview.1" />

Add the crates

The crates are on crates.io, which Cargo uses by default.

Pick a crate

Crate	Use it as	What it contains
`datalium-strata`	`datalium_strata`	The engine: graphs, validation, streaming, interrupts, retries, and the `#[strata_tool]` and `#[derive(StrataSchema)]` macros through `datalium_strata::prelude`.
`datalium-strata-memory`	`datalium_strata_memory`	Checkpoint and history stores: in-memory, SQLite, Postgres and Redis. Also long-term memory stores for Postgres, SQLite and Redis.
`datalium-strata-cloud`	`datalium_strata_cloud`	For the Strata Cloud private beta: the Cloud checkpoint store, its decisions client and a decision worker.
`datalium-strata-host`	`datalium_strata_host`	Settings, background drivers that run as tasks, and a store health probe.
`datalium-strata-ai`	`datalium_strata_ai`	Model calls, agents, model routes, embeddings and long-term memory, with clients for OpenAI-compatible servers and Anthropic.
`datalium-strata-macros`		The procedural macros. You don’t add it yourself: `datalium-strata` depends on it.

Most applications start with datalium-strata and datalium-strata-memory, and add the others as they need them.

Add the dependencies

Add the crates you picked to Cargo.toml, all at the same version, together with tokio and serde:

[dependencies]
datalium-strata = "=0.9.0-preview.1"
datalium-strata-memory = "=0.9.0-preview.1"
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

The = pins the exact version. A preview promises nothing between previews, and without the = Cargo would also accept a later preview, or 0.9.0 itself.

You can add them from the command line instead. Put = after the @ to pin the exact version the same way:

cargo add datalium-strata@=0.9.0-preview.1 datalium-strata-memory@=0.9.0-preview.1

datalium-strata-ai has two features, openai and anthropic, both on by default. Turn off the one you don’t use with default-features = false and features = [...].

Install the strata CLI

The strata command checks exported graph definitions and inspects threads and checkpoints in a store. It’s a single binary.

Download it. Each release on GitHub has a binary for each platform, and a SHA256SUMS.txt file to check them against:

Platform	File
Linux (x86-64)	`strata-linux-x64`
macOS (x86-64)	`strata-macos-x64`
Windows (x86-64)	`strata-windows-x64.exe`

Download the one for your platform and rename it to strata (strata.exe on Windows). On Linux or macOS, make it executable with chmod +x strata. Then put it on your PATH.

There is no build for ARM64 yet (see Known limitations).

Or build it from source. With Rust installed, clone the repository at the release tag:

git clone --branch v0.9.0-preview.1 https://github.com/datalium/strata
cd strata/cli
cargo build --release --bin strata

The binary is cli/target/release/strata (strata.exe on Windows). Copy it to a folder on your PATH.

The CLI reference lists every command.

Check the install

Check the CLI:

strata --version

It prints:

strata 0.9.0-preview.1

To check the packages or crates, build and run the Quickstart. If it prints Hello, Ada!, everything is in place.