Features

Liath is the SQLite for AI agents: an embedded, programmable memory database with a Rust core. Agents query their memory by writing sandboxed Lua, backed by a key-value store, vector search, and embeddings in a single dependency.

Programmable Memory

The core idea: agents query their memory with sandboxed Lua programs, not fixed APIs

Programmable Queries in Lua

Agents write Lua programs to query their own memory. Custom retrieval, ranking, filtering, and cross-referencing — logic that fixed vector-DB APIs simply cannot express.

Sandboxed Execution

Running agent-generated code is normally dangerous. Liath executes Lua in a strict sandbox with no file, network, or system access. Safe by construction.

Storage & Search

Key-value, vector search, embeddings, and namespaces built into one embedded engine

Key-Value Storage

Built-in namespaced key-value store backed by Fjall. Persistent, atomic, and typed — the foundation for agent state, configuration, and structured memory.

Vector Search

Similarity search over embeddings powered by USearch. Store vectors alongside your key-value data and run nearest-neighbor queries from inside Lua.

Built-in Embeddings

FastEmbed generates text embeddings locally. store_with_embedding() and semantic_search() turn plain text into searchable memory automatically.

Namespaces

Isolate data per agent, tenant, or environment. Namespaced storage keeps multi-agent systems from stepping on each other while sharing one embedded engine.

Agent Primitives

Memory, conversations, and tool state designed for how agents actually work

Agent Memory Primitives

Store memories with tags and importance scores, then recall by tag or by semantic similarity. Memory that maps directly onto how agents actually reason.

Conversation History

First-class conversation tracking: add_message() and get_messages() manage multi-turn history per conversation without bolting on a separate store.

Tool State

Persist and retrieve tool state between steps with set_tool_state() and get_tool_state(). Give long-running agents durable working memory across a task.

Runtime & Interfaces

Embedded Rust core with library, CLI, TUI, HTTP, and MCP interfaces

Embedded, Zero-Infrastructure

No server to run, no cluster to operate. Liath embeds directly in your process as a single dependency. Point it at a data directory and go.

Rust Core

The engine is written in Rust: memory-safe, fast, and portable. Low-latency execution suited to real-time agent loops, with a Python binding on top.

Multiple Interfaces

Use Liath as an embedded library, an interactive TUI/CLI, an HTTP server, or an MCP server that plugs directly into AI assistants and agent frameworks.