Meet LUMO — the firefly that lights the way for agents and humans

One database for agents
and humans, doing more with less RAM

The shared system of record for your team and your agents: agents work it over 27 MCP tools, humans over SQL, a REPL, and Python/Node SDKs. Same engine, same data, same governance — columnar storage with zstd underneath. One binary, zero daemons.

MIT-licensed · 27 MCP tools for agents · SQL for humans · One audit trail

One curl command.

Prebuilt releases for macOS (Apple Silicon) and Linux x64 ship from Cloudflare's edge. The installer picks the right tarball for your machine and puts less on your PATH.

$ curl -fsSL https://lessdb.dev/install.sh | sh
Claude Code Cursor Gemini CLI Codex CLI Windsurf GitHub Copilot Cline JetBrains AI Apache Arrow pandas pyarrow Node.js

Works with any MCP client  |  27 agent tools  |  Storage: s3:// gcs:// az:// file:// memory://  |  Packages served from Cloudflare

Same data. Two front doors.

Agents call MCP tools — query, schema, search, link. Humans run SQL in the REPL or through the SDKs. Both hit the same engine and the same data; what one side writes, the other side sees.

  • 27 MCP tools for agents, SQL REPL for humans
  • One engine, one data dir — nothing to sync
  • WAL-protected writes — durable before they return
less mcp · the agent door LIVE
$ less mcp --dir mydb
initialize → 27 tools ready
tool_call less_query "SELECT count(*) FROM events"
result 4,102,559 rows · 7.9 ms
tool_call context_put proj/lessdb "LessDB" --tag db
result note stored · visible to the team
tool_call context_link task/123 proj/lessdb depends_on
result link created · graph updated
tool_call vector_search docs '[1,0,0]' --k 2
result #1 rust (0.997) · #2 rust-like (0.921)
$
less · the human door
$ less insert events --csv events.csv
5,000,000 rows · 8.5× compressed · 42 MB RSS
$ less sql "SELECT kind, sum(amount) FROM events GROUP BY kind"
click 462,108.35 · view 31,552.09 · 7.9 ms warm

Agents and humans, same data, same database.

01

“What do my agents see that my team doesn't?”

Nothing, and that's the point. Two front doors on one engine: agents get tool-shaped access — query, schema, stats, search, link — while people get SQL, the REPL, and SDKs. Same tables, same vectors, no exports, no drift.

02

“Why run one system for agents and another for people?”

Split systems drift and double your ops. LessDB keeps SQL, vector search, and linked knowledge in one engine, so agent work and human work always agree on the same data.

03

“What happens when the work outgrows one machine?”

Point tables at shared object storage and compute nodes become stateless — durable data lives in the shared store. Scale the swarm, not the toil.

Everything both sides need, embedded.

MCP server, 27 tools

One stdio connection: query, schema, stats, tables, search, and links — for Claude Code, Codex, Cursor, and any MCP client.

Full SQL

Joins, CTEs, window functions, and subqueries with a cost-based optimizer. The REPL, the SDKs, and agents all run the same engine.

Knowledge graph

Titled, tagged notes with typed links, BFS, shortest paths, and ranked search — plus RAM tables with point lookups.

Vector search built in

Named vector spaces with l2/cosine/dot metrics. Exact flat search plus IVF-PQ ANN with exact re-ranking — 0.87 recall@10 at 8.7k QPS.

Columnar storage

Immutable data parts with per-column zstd/lz4 compression. Typed min/max stats and bloom filters prune parts before any I/O.

Shared object storage

Tables on S3, GCS, or Azure Blob: any node with the same URL sees the data instantly — compute is cattle.

GPU kernels

wgpu-accelerated filtered sums and dot products — Metal on macOS, Vulkan on Linux — with an always-on CPU fallback.

Observable by default

Prometheus metrics with pruning effectiveness, query histograms, auth failures, and memory — exposed at GET /metrics.

LDAP / AD auth

Fail-closed group→role mapping over LDAPS, injection-safe user filters, and role-based authorization on every HTTP endpoint.

Same rules for agents and humans.

One identity model, one role model, one audit trail — across the MCP door, the HTTP door, and the SDKs. An agent is just another caller: it gets a credential, a role, and a record of everything it did.

  • admin / read / write roles on every door — fail-closed
  • Per-agent identity and tenancy; table grants keep agents apart
  • Every call recorded — caller, tool, SQL, outcome, cost
  • Human approval gates for agent writes and schema changes
less audit · one trail, both doors RECORDING
$ less audit --since 1h
door caller action outcome
http human:maruthi SELECT … ok · 4.1M rows · 7.9 ms
mcp agent:claude less_query "SELECT…" ok · 4.1M rows · 7.9 ms
mcp agent:claude less_optimize events denied · role: read
mcp agent:claude context_put proj/lessdb ok · tenant: alice
http human:maruthi approval #48291 accepted → less_optimize

Small footprint.
Serious numbers.

Every figure below comes from the bundled benchmark harness — deterministic seeded data, reproducible on a MacBook-class dev machine, committed to the repo.

0
agent tools over one MCP connection
0×
zstd storage compression (lineitem)
0 ms
p99 point lookup, bloom-pruned
0
vector searches / sec (IVF-PQ)
0 MB
RSS after loading 86k rows

Zero to a shared database in ~2 minutes

The complete guide, start to finish. Install, ingest, query — then open the same data to your agents over MCP and your team over SQL and the SDKs.

1

Install with curl

One line installs the prebuilt less binary (macOS arm64, Linux x64).

$ curl -fsSL https://lessdb.dev/install.sh | sh

# The installer fetches the release for your OS/arch from the
# Cloudflare package host and puts `less` on your PATH.
$ less --version                            # lessdb 0.1.0

# Prefer building from source? (Rust ≥ 1.85)
$ cargo install --path crates/less-cli --features cloud,gpu

The installer only writes to ~/.lessdb plus one PATH line — delete both to uninstall.

2

Your first database

$ less init        # creates .less/ here — or --dir /data/mydb
3

Tables + data

$ less create "CREATE TABLE events (
    id Int64, kind String, amount Float64, ts DateTime
) ENGINE = MergeTree ORDER BY (kind, id) UNIQUE (kind) COMPRESSION = 'zstd'"

# CSV headers map to columns (any order); empty/`\N` cells are NULL:
$ less insert events --csv events.csv          # or --jsonl / --parquet / --arrow
$ less sql "INSERT INTO events VALUES (2, 'view', 1.5, '2025-01-01 10:01:00')"
$ less sql "COPY (SELECT * FROM events) TO 'export.parquet'"
4

Query (SQL-first)

$ less sql "SELECT kind, count(*) AS c, sum(amount) AS total
          FROM events GROUP BY kind ORDER BY total DESC"

$ less sql "SELECT * FROM events WHERE kind = 'click' AND ts > '2025-01-01'"

$ less sql                                      # interactive REPL (end with ;)
$ less sql "EXPLAIN SELECT ..."                 # plan + part-pruning info

Full SQL surface: joins, CTEs, window functions, subqueries. UNIQUE columns dedup keep-last at flush/merge; run less optimize events to enforce across parts. less describe events / less parts events show storage state.

5

Vector search

$ less vector create docs 3 --metric cosine                    # flat exact
$ less vector create big 256 --index ivf_pq --nlist 64 --m 8   # ANN
$ less vector add docs --vectors '[[1,0,0],[0,1,0],[0.9,0.1,0]]' \
                    --payloads '[{"title":"rust"},{"title":"python"},{"title":"rust-like"}]'
$ less vector search docs '[1,0,0]' --k 2
$ less vector embed "rust database"        # built-in trigram embedder (demo)

# SQL, too — and you can join/filter the hits:
$ less sql "SELECT id, payload FROM vector_search('docs', [1.0,0.0,0.0], 10)
          WHERE payload LIKE '%rust%'"
6

Knowledge graph: contexts + links

Link notes, tasks, and projects in the same data dir — no extra services.

$ less context put proj/lessdb "LessDB" "Analytical DB in Rust" --tag db --kind project
$ less context put task/123 "GPU kernels" "wgpu filtered-sum + dot" --tag gpu --kind task
$ less context link task/123 proj/lessdb depends_on
$ less context find gpu
$ less context neighbors task/123 && less context path task/123 proj/lessdb

$ less memory create people --field id:Int64 --field name:Utf8 --pk id
$ less memory insert people '[{"id":1,"name":"ada"},{"id":2,"name":"grace"}]'
$ less memory sql "SELECT count(*) FROM people"

Everything persists under .less/memory/.

7

Open the agent door (MCP)

One stdio connection exposes 27 tools to any MCP client — no plugins, no sync jobs.

$ less mcp            # stdio JSON-RPC, uses --dir .less by default

# Lock the door and hold agents accountable:
$ less token create claude --role read --tenant default   # prints the token once
$ less mcp --require-auth      # tokens required, roles enforced, fail-closed
$ less audit --since 24h       # every call, both doors, newest first

Claude Code:

$ claude mcp add lessdb -- less mcp --dir /abs/path/to/mydb

Claude Desktop claude_desktop_config.json:

{ "mcpServers": { "lessdb": { "command": "less", "args": ["mcp", "--dir", "/abs/path/to/mydb"] } } }

Agents get 27 tools: less_query/explain/schema/stats/tables/optimize, context_*, memory_*, vector_*.

8

HTTP server (+ Prometheus, LDAP)

$ less server --addr 127.0.0.1:7080
$ curl -s localhost:7080/health
$ curl -s localhost:7080/v1/sql -H 'content-type: application/json' \
     -d '{"sql":"SELECT count(*) FROM events"}'          # JSON
$ curl -s localhost:7080/metrics                           # Prometheus text

# LDAP/AD auth (fail-closed group→role mapping):
$ less init --auth @auth.json   # see docs/ARCHITECTURE.md §9 for the schema
$ curl -u alice:secret -H 'content-type: application/json' \
     -d '{"sql":"SELECT 1"}' localhost:7080/v1/sql

Prometheus:

scrape_configs:
  - job_name: lessdb
    static_configs: [{ targets: ["localhost:7080"] }]
9

Cloud-native: compute/storage separation

$ less init --shared s3://my-bucket/lessdb        # parts + catalog in S3

Any node with the same --shared URL sees the same tables instantly; local disk stays ephemeral (buffers/caches only). file:// for local dev.

10

Python / Node (embedded)

# # npm — the CLI as a package (postinstall fetches + verifies the binary):
$ npm install -g lessdb
$ lessdb sql "SELECT 40 + 2"
$ npx lessdb --version        # one-shot, nothing installed

# Homebrew — same binary from the same host:
$ brew tap maruthiprithivi/lessdb
$ brew install lessdb

Benchmarks & GPU

$ less bench --rows 5000000     # insert + scan/filter/group-by throughput
$ less gpu                      # GPU vs CPU kernels (Metal/Vulkan)
$ less metrics                  # this process's Prometheus metrics

More: README.md, docs/ARCHITECTURE.md, docs/ROADMAP.md, and the agent skills in skills/.

One database for agents and humans.

Agents over MCP, people over SQL, the REPL, and SDKs — same engine, same data. Rust, MIT license, macOS & Linux.

$ less init — that's the whole setup.