Liath vs Chroma
Liath and Chroma can both run embedded and both do vector search over embeddings. Chroma is a developer-friendly embeddings database organized around collections with a simple API. Liath is programmable agent memory: agents query it by writing sandboxed Lua programs, and it bundles a key-value store, vector search, embeddings, and agent primitives (tagged memory, conversations, tool state) on a Rust core. Choose Liath for programmable, agent-native memory; choose Chroma for a simple, popular RAG-focused embeddings API.
Verdict: Chroma is a developer-friendly embeddings database focused on vector collections; Liath is programmable agent memory that adds sandboxed Lua queries, key-value storage, and agent primitives around the same core capabilities.
Liath strengths
- Agents write sandboxed Lua to run custom retrieval and ranking logic
- Key-value store, vector search, and embeddings in one Rust engine
- Agent primitives: tagged memory with importance, conversations, tool state
- Runs embedded, as a CLI/TUI, an HTTP server, or an MCP server
- Rust core for low-latency execution in real-time agent loops
Chroma strengths
- Simple, popular Python-first API for adding and querying embeddings
- Large community and broad framework integrations for RAG
- Collections model with metadata filtering is easy to learn
- Well-documented workflows for common embedding use cases
- Mature client libraries and tutorials
Overview
Chroma is a well-liked embeddings database: add documents to a collection, query by similarity, filter on metadata. It is a great fit for straightforward RAG. Liath overlaps on the basics — it also runs embedded and does semantic search over embeddings — but it is built as programmable memory for agents.
Programmability
The defining difference is how you query. Chroma exposes an API you call from application code. Liath lets the agent write a sandboxed Lua program that runs inside the engine: search, filter by recency and importance, re-rank by a custom score, and shape the output in one execution. The Lua sandbox blocks file, network, and system access, so agent-generated code is safe to run.
More than a vector store
Chroma focuses on embeddings and collections. Liath bundles a key-value store (Fjall), vector search (USearch), and embeddings (FastEmbed), plus agent primitives — tagged memory with importance scores, conversation history, and tool state. That means an agent’s structured state and its semantic memory live in one engine.
Interfaces and core
Liath runs embedded or as a CLI, TUI, HTTP server, or MCP server, and its core is written in Rust for low-latency execution in agent loops. Chroma is Python-first with a broad integration ecosystem.
When to choose
Choose Chroma when you want the simplest embeddings API for a RAG app. Choose Liath when you want agents to program their own retrieval and keep memory, vectors, and state in one place. Compare also Liath vs Pinecone and see RAG pipelines.
Feature Comparison
| Feature | Liath | Chroma |
|---|---|---|
| Programmable Lua Queries | Yes | No |
| Sandboxed Code Execution | Yes | N/A |
| Embedded / In-Process | Yes | Yes |
| Vector Similarity Search | Yes | Yes |
| Built-in Key-Value Store | Yes | No |
| Built-in Embeddings | Yes | Yes |
| Agent Memory Primitives | Yes | No |
| MCP Server | Yes | Partial |
| Rust Core | Yes | No |
| Open Source | Yes | Yes |
Choose Liath when
- → You want agents to express retrieval logic as code, not fixed calls
- → You need KV, vectors, and embeddings together in one dependency
- → You want built-in conversation and tool-state memory
- → You want an MCP server to plug memory into agent frameworks
- → You value a Rust core for performance and portability
Choose Chroma when
- → You want the simplest possible embeddings API for a RAG prototype
- → You rely on Chroma's specific ecosystem integrations
- → A collections-and-metadata model fully covers your retrieval needs
- → Your team is standardized on Chroma's Python workflow
- → You do not need programmable in-engine query logic
Frequently Asked Questions
How is Liath different from Chroma?
Chroma is an embeddings database centered on vector collections with a simple API. Liath adds programmable sandboxed Lua queries, a built-in key-value store, and agent primitives like tagged memory, conversations, and tool state, on a Rust core. The core difference is programmability: agents write query logic as code.
Can both run embedded?
Yes. Both Liath and Chroma can run embedded in your application. Liath additionally offers CLI, TUI, HTTP, and MCP interfaces, and bundles key-value storage alongside vectors.
Is Liath good for RAG like Chroma?
Yes. Liath supports semantic search over embeddings and lets an agent assemble context in a single Lua program. See our RAG pipelines use case for details on building retrieval with Liath.
Which has the simpler API?
Chroma's collections API is very approachable for basic add-and-query workflows. Liath trades a little of that simplicity for programmability — the ability for agents to write custom retrieval and ranking in Lua.
Does Liath store more than vectors?
Yes. Liath includes a namespaced key-value store (Fjall) alongside vector search (USearch) and embeddings (FastEmbed), so structured state and memories live in the same engine.