# Docs

- Guides: Using Loams
  - [Introduction](/docs): Understand Loams, choose an API, and run your first hybrid query.
  - [Platform capabilities](/docs/platform): What is implemented across Loams, from retrieval and durable execution to SDKs, graphs, analytics, agents and native applications.
  - [Quickstart](/docs/quickstart): Build Loams, write documents, and run a hybrid vector and keyword query.
  - [Roadmap](/docs/roadmap): Track the full Loams platform: implemented components, integration work and future services.

  - **Developer guide**
  - [Developer guide](/docs/developer): From nothing installed to a working app on Loams, step by step, in your language.
  - [Install the CLI and Loams Desktop](/docs/developer/install): Download the loams CLI or Loams Desktop for your platform, and verify it against the release checksums and the project's GPG key.
  - [Run Loams locally](/docs/developer/run-locally): Start the engine on your own machine with loams dev, see which listeners it opens, and check that it is ready.
  - [First collection and hybrid search](/docs/developer/first-collection): Create a collection over the native REST API, write documents with vectors, and run one query that fuses vector kNN, BM25 and a filter.
  - SDKs
    - [SDKs](/docs/developer/sdks): The Loams SDKs, what they cover in 0.1.0, how to install each one, and where the example repositories are.
    - [TypeScript](/docs/developer/sdks/typescript): Install @loams/client, make the first call, and run a hybrid query from TypeScript.
    - [Python](/docs/developer/sdks/python): Install the loams package, make the first call, and run a hybrid query from Python.
    - [Go](/docs/developer/sdks/go): Install loams.dev/go and make the first call from Go.
    - [Rust](/docs/developer/sdks/rust): Add the loams crate and make the first call from Rust.
    - [C#](/docs/developer/sdks/csharp): Add the Loams NuGet package and make the first call from .NET.
    - [C++](/docs/developer/sdks/cpp): Use the Loams C++ SDK from CMake and make the first call.
    - [Swift](/docs/developer/sdks/swift): Add the Loams Swift package and make the first call.
    - [Java](/docs/developer/sdks/java): Use the Loams Java SDK (dev.loams:loams) and make the first call.
    - [Kotlin](/docs/developer/sdks/kotlin): Use the Loams Kotlin SDK (dev.loams:loams-kotlin) and make the first call.
    - [Ruby](/docs/developer/sdks/ruby): Use the loams gem and make the first call from Ruby.
    - [PHP](/docs/developer/sdks/php): Use the loams/loams Composer package and make the first call from PHP.
  - [Compatible clients](/docs/developer/compatible-clients): Use Qdrant, Elasticsearch, Arrow Flight SQL, Postgres and MySQL clients against Loams.
  - [Authentication and API keys](/docs/developer/auth): The engine's four auth modes, which one to use where, and how to mint and use an API key.
  - [Consistency tokens](/docs/developer/consistency): How to read your own writes in Loams, in one process and across processes, with the Loams-Consistency-Token header.
  - [Troubleshooting](/docs/developer/troubleshooting): The problems developers hit first with Loams, and how to fix each one.

  - **Self-hosting**
  - [Self-hosting over Tailscale](/docs/self-hosting/tailscale): Run the Loams 0.1.0 stack with Docker or Podman Compose on your laptop or your own VM, reachable only over your Tailscale tailnet, and use it from console.loams.dev.

  - **Concepts**
  - [Data model](/docs/concepts/data-model): Namespaces and the five kinds of objects they contain.
  - [The log and consistency](/docs/concepts/log-and-consistency): How a write travels through Loams and why any read can see it.
  - [Storage and the hot tier](/docs/concepts/storage-and-hot-tier): What lives in the bucket, and what compute nodes keep to make it fast.
  - [Links and workers](/docs/concepts/links-and-workers): Declarative materialization with exactly-once apply, run by a stateless worker pool.

  - **Reference**
  - [API reference](/docs/reference/api): Interactive references for every Loams API, with the status of each.
  - [HTTP API](/docs/reference/http-api): The native JSON API for namespaces, streams, CloudEvents and links.
  - [CLI](/docs/reference/cli): Run the Loams engine locally, against your bucket, or as a cluster.
- Learn: How Loams works
  - [How Loams works](/docs/learn): A one-page tour of Loams, and where to read next for app developers, data engineers, platform teams and agent builders.
  - Concepts: The ideas everything else is built on
    - [The bucket is the source of truth](/docs/learn/concepts/bucket-as-source-of-truth): Why object storage holds every durable byte of the Loams engine, and what that buys you and costs you.
    - [The log is the spine](/docs/learn/concepts/log-is-the-spine): Every write enters an ordered log first; collections and tables are materialized from it by links.
    - [Collections and manifests](/docs/learn/concepts/collections-and-manifests): How one immutable manifest binds a Lance dataset and Tantivy splits into a consistent snapshot of a collection.
    - [Consistency tokens](/docs/learn/concepts/consistency-tokens): Read-your-writes without locks. What a token is, what a read does with it, and why it never waits for indexing.
    - [Hybrid retrieval](/docs/learn/concepts/hybrid-retrieval): Dense vectors, BM25, sparse vectors and filters in one query plan, fused into one ranked list.
    - [The hot tier](/docs/learn/concepts/hot-tier): RAM and NVMe layers that keep hot data next to compute, rebuild from the bucket, and never change an answer.
    - [Stateless compute](/docs/learn/concepts/stateless-compute): Engine nodes hold only state they can rebuild, so they start, scale and fail cheaply.
    - [Namespaces and tenancy](/docs/learn/concepts/namespaces-and-tenancy): The namespace is the unit of isolation, layout and placement; roles, quotas and organizations build on it.
    - [Open formats](/docs/learn/concepts/open-formats): Lance, Tantivy splits and, next, Iceberg. Your data stays readable by other tools, without Loams running.
    - [OLTP, OLAP and HTAP](/docs/learn/concepts/oltp-olap-htap): Transactions, analytics and both at once. Where each Loams workload sits, and why commits stay off the bucket.
  - Architecture: How the pieces fit together
    - [Architecture overview](/docs/learn/architecture/overview): The engine's five roles, its metastore and its bucket, and how the other Loams products sit beside it.
    - [The write path](/docs/learn/architecture/write-path): From an API call to a durable log entry, an acknowledged token and, seconds later, a new collection manifest.
    - [The read path](/docs/learn/architecture/read-path): How a query is routed to an owner, planned at one snapshot, served from cache or the bucket, and merged with the unindexed tail.
    - [Metadata and TiKV](/docs/learn/architecture/metadata-and-tikv): Where metadata lives. One semantic MetaStore interface, the embedded Raft default, and TiKV for clusters and the self-hosted stack.
    - [Cluster mode](/docs/learn/architecture/cluster-mode): Several engine nodes with meta, log, query, worker and gateway roles, placed by rendezvous hashing over leases.
    - [Security model](/docs/learn/architecture/security-model): The trust boundaries of a Loams deployment today, how requests are authenticated, and what is designed next.
  - Products: Every Loams product, explained
    - [The Loams engine](/docs/learn/products/engine): Hybrid retrieval over collections that live in your bucket as Lance and Tantivy, served through native, Qdrant, Elasticsearch, Flight SQL and SQL-wire APIs.
    - [Loams Live](/docs/learn/products/live): A Convex-style reactive document database: mutations are transactions, queries stay live, on TiKV or an embedded store.
    - [Loams Graph](/docs/learn/products/graph): A property graph database with GQL, embedded in the Loams engine on Loams' fork of Grafeo, with its writes in the Loams log and its snapshots in the bucket.
    - [Loams House](/docs/learn/products/house): ClickHouse-compatible analytics on chDB, in sealed worker processes, over Iceberg tables in your bucket.
    - [Loams SQL](/docs/learn/products/loams-sql): MySQL-compatible SQL on a patched TiDB over Loams' TiKV, one keyspace per database branch, heading toward a Neon-like serverless MySQL.
    - [Loams Postgres](/docs/learn/products/postgres): Serverless Postgres from Loams' hard fork of Neon, with storage in your bucket, copy-on-write branches and computes that start on demand and suspend when idle.
    - [Loams Durable](/docs/learn/products/durable): Durable promises and tasks for agent runs and long operations, served by a Resonate server embedded in the loams binary.
    - [Loams Studio](/docs/learn/products/studio): An agentic development environment in the Loams console: coding agents in their own git worktrees, with review, checkpoints, approvals and parallel runs, all through loams-agentd.
    - [Loams Git](/docs/learn/products/git): Git repositories stored on the bucket as a write-ahead log of create-only segments, with checkpoints, O(1) forks and a remote helper that needs no server.
    - [Loams Software Factory](/docs/learn/products/software-factory): The self-hosted development toolchain that Loams Desktop and Studio bring into one window: Forgejo, Zulip, Plane, GlitchTip, OpenPanel, Matomo, Langfuse and OpenObserve, and the planned loop in which agents take an issue to a reviewed pull request.
    - [Loams Desktop and the loams CLI](/docs/learn/products/desktop-and-cli): The Electron desktop app that runs the console, a local engine and the agent daemon on your machine, and the one loams binary that runs, upgrades and administers a Loams stack.
    - [SDKs](/docs/learn/products/sdks): Seven Loams client libraries, generated from one set of protos, held to one runtime contract and checked against one recorded fixture corpus.
  - Decisions: Why Loams is built the way it is
    - [Key decisions](/docs/learn/decisions): The two dozen decisions that shaped Loams, why each was made, what was rejected, and which ones were later reversed.