Loams

One bucket, every index: hybrid retrieval on object storage, with reactive data and durable agent runs beside it.

Loams is an open-source, AI-native data platform in Rust. It keeps your data in your object-storage bucket (S3, GCS, Azure Blob, RustFS or a local directory) in open formats: Lance and Tantivy today, Iceberg next. Compute is stateless and holds only caches.

0.1.0 — first release. You run the stack yourself with Docker Compose, locally or on your own VMs, over your own Tailscale tailnet, and use the hosted console at console.loams.dev. 0.x: APIs and on-disk formats may change between minor versions; upgrades are supported with loams upgrade.

Run Loams · Documentation · Website · API reference · Contributing

Why Loams

A typical AI application runs Elasticsearch, Qdrant, a graph database, Kafka and a workflow engine: five stateful clusters, several copies of the same data, and retrieval glued together in application code. Loams replaces them with one engine on one bucket:

Your bucket is the source of truth. Object-storage prices, no 3× block-storage replication; losing a node loses no data.
The log is the spine. Every write lands in a log; collections are materializations of it, and every write returns a consistency token later reads can wait on.
Hybrid retrieval in one plan. Vectors, BM25 and filters fused with RRF in one DataFusion query, with hot tiers in RAM and NVMe.
Drop-in APIs. Existing Qdrant and Elasticsearch clients (and LangChain and LlamaIndex on top of them) work unmodified, plus Arrow Flight SQL.
More than retrieval. Reactive documents (Live), graphs (Graph), analytics (House), MySQL and Postgres, and durable agent runs (Durable), on the same storage.

Read the pitch and the architecture.

What ships in 0.1.0


Retrieval engine	Collections, hybrid search, SQL, streams and links; native REST, Arrow Flight SQL, Qdrant and Elasticsearch APIs; Postgres and MySQL wire
Loams Live	A reactive document database: transactions, indexes and live queries
Loams Graph	GQL graphs, with writes on the Loams log and crash recovery. Experimental: graph expansion for GraphRAG (1 to 2 hops from search hits, and SQL `graph_*` functions)
Loams House	Experimental. ClickHouse-compatible analytics with engine-level access control (opt-in profile)
Loams SQL / Postgres	MySQL on a patched TiDB; Postgres on our Neon fork, storage on the bucket
Loams Durable	Durable promises and tasks for agent runs (an embedded Resonate server)
Console, desktop, CLI	Hosted web console; Loams Desktop and the `loams` CLI for Linux, macOS and Windows
Loams Studio	Experimental. An agentic development environment in the console's Studio mode: coding agents (Claude Code, Codex, opencode and others) in threads with a git worktree each, diff review, git actions, terminals, previews and parallel runs, all through the `loams-agentd` daemon. On by default in Loams Desktop; in the browser it runs against a remote `loams-agentd` and is behind a feature flag (guides)
Loams Git	Experimental. `git-remote-loams`, git's remote helper, ships with the `loams` CLI packages: `git clone`, `fetch` and `push` reach a Loams Git repository on a bucket, with no server in between
SDKs	TypeScript, Python, Go, Rust, C#, C++ and Swift (more languages coming). Published to npm, PyPI, crates.io, NuGet and the Go proxy as `0.1.0`; Swift from the release tag, C++ as a release tarball

Coming next: Loams Git on the server (repositories in the release images), first-party connectors, Iceberg analytics, Kafka wire, functions and jobs. The full status table is in Running Loams; the plan is in the roadmap.

Quick start

Run the whole stack (needs Docker Compose and a Tailscale auth key):

git clone https://github.com/ostrium-labs/loams.git
cd loams/deploy/release
cp .env.example .env        # set TS_AUTHKEY
docker compose up -d

Then open console.loams.dev on a device on the same tailnet and enter https://loams.<your-tailnet>.ts.net. Details, BYOC over SSH and auth modes: Running Loams.

Or build just the engine and run it on one machine:

cargo run --release -p loams -- dev    # native API on 127.0.0.1:8080, Qdrant on :6333, Elasticsearch on :9200

Examples for the native API, Qdrant clients, Flight SQL and reading the bucket directly are in the engine quick start.

Repository

The engine crates, the web console, Loams Desktop, the mobile apps, SDKs, protos, connectors and deploy files all live here; see the project layout and the monorepo guide. Design documents are in docs/design and task-by-task plans in docs/plans.

Contributing and community

Bug reports, client compatibility reports, docs fixes, tests and code are all welcome. Start with CONTRIBUTING.md and issues labelled good first issue; open an issue before changing a format, protocol or design decision.

Discussions · Issues · Security · Code of Conduct · Governance · Ecosystem · Privacy

Code signing policy

Linux and checksums: the release workflows sign .deb, .pacman, AppImage and SHA256SUMS with the project GPG key, set up on 2026-10-16; .rpm packages are planned for SignPath. The previews so far shipped without it: a file built without its signing credentials is named -unsigned, as every v0.1.0-preview.2 desktop file is, and the release notes say so.
Windows and macOS: unsigned today. The Windows (Authenticode) and .rpm signing steps through SignPath Foundation are built into the release workflows, but the application is not made yet, so nothing is signed that way; it will be made once the project has traction. macOS stays unsigned and not notarized.
Verify a download: sha256sum -c SHA256SUMS --ignore-missing, then gpg --import docs/release/loams-release-key.asc (fingerprint 333A C945 99D5 A1EB 2A41 6D1E 83DC 134D 8CAF 895D) and gpg --verify SHA256SUMS.asc SHA256SUMS.
Roles: the three SignPath roles (authors, reviewers, approvers) are the repository's maintainers and owners; the named people will be listed here once the application is approved. Details: signing policy, desktop releases.

License

Apache License 2.0. Loams builds on DataFusion, Lance, Tantivy, Quickwit, qdrant-edge, SlateDB, openraft, TiKV, TiDB, Neon, Grafeo, chDB and Resonate; attributions are in NOTICE. Everything needed to self-host Loams is open source here; only metering, billing and the commercial APIs are proprietary (open core).

loams

Runtime