Skip to content

Latest commit

 

History

654 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

KyzoDB logo

KyzoDB

One language for similarity, structure, time, and proof —
on one deterministic substrate where answers replay, explain, or refuse.

CI Fuzz (nightly deep run) CodeQL Rust 1.96.1, pinned License: MPL-2.0

Note

Latest binary release: v0.8.1. Pre-1.0 by design: the public API is not frozen, and we do not publish yardstick latency/throughput until measured with methodology and losing runs (VERSIONING.md). The board is live status.

Install

Linux x86_64:

curl -L https://github.com/kyzodb/kyzo/releases/download/v0.8.1/kyzo -o kyzo
chmod +x kyzo
./kyzo

Thirty seconds later you have a REPL. A join is shared variables — not JOIN:

KyzoDB REPL: create cites and runbook, join them, get rows.

Or skip the typing and run the ops-world demo that seeds incidents, privilege edges, HNSW, claims, and coverage, then asks the knowing question:

# with a release binary on PATH, or after: cargo build -p kyzo-bin --release
./examples/readme/demo.sh

Embed like SQLite — no server; a database is a file handle:

Rust: Db::new + new_fjall_storage + run_script.

Other targets: cargo build -p kyzo-bin --release.

Why the usual stack fails

Five stores drift; KyzoDB collapses them to one language, one transaction.

Keeping facts, vectors, graph, text, and history in sync is the second product nobody asked for. KyzoDB collapses them to one query, one transaction, one snapshot.

The question a stitched stack can’t ask

Vector DBs don’t join. Graph DBs don’t mean. Audit logs don’t query. KyzoScript (Datalog) treats search hits as relations — so similarity, recursion, negation, and privilege closure compose in one program.

Near live prod unclaimed incidents with runbooks while attacker reach includes db-customers.

Near this alert · live · prod · has a runbook · no claim yet · and the attacker can still reach db-customers. That is retrieval as knowing, not a fan-out pipeline.

The same program shape also joins full-text hits the same way — hybrid retrieval is a join, not a fusion microservice. See examples/readme/demo.sh for a runnable seed of this world.

Time is a coordinate

Correct the record; as-of the incident date still returns what was believed then — a seek, not a change-log archaeology project. Same ops memory: customer C-77 was trial when the incident fired, enterprise after the correction:

As-of reads: coverage trial on the incident date, enterprise today.

Filtered search that cannot come back empty

Anyone who has run a vector database knows the failure: fill k, then filter, watch the set go empty at low selectivity. Here the filter is inside the search; k counts matches:

Naive post-filter ANN empty; KyzoDB filtered HNSW returns min(k, matches).

The engine keeps its word

Ask it to prove a recursive answer against its own oracle — or hit a budget and get a typed refusal. Same facts and budget also produce byte-identical answers across thread counts:

::verify returns match when engine and reference oracle agree.

Typed budget refusal: eval::limit_exceeded.

Same reach query row hash under 1 and 32 Rayon threads.

Why you can believe that

KyzoDB ships its own adversary: a deliberately naive reference oracle that speaks the whole language. Generated workloads are answered twice; the answers must match.

Optimized engine and naive oracle must agree on every generated program.

  • Oracle — stratified Datalog semantics as an executable, slow, obviously-correct evaluator.
  • ::verify — user surface: match, budgeted refusal, or a reproducible mismatch bundle.
  • Determinism — seeded campaigns at multiple thread counts demand byte-identical answers and refusals.
  • Typed refusals — wrong shape, exceeded budget, unsafe program → named error, never panic.
  • One law — memcomparable keys: binary order equals semantic order, so every access path is a range scan on one substrate.

Answers that show their work

When an agent must not get it wrong, a derived fact names the premises that entailed it — re-checked by an independent checker that imports nothing from the evaluator:

Provenance proof: must_clear derived from ground facts, checker Ok.

Architecture

KyzoScript → relational algebra → relational/graph/HNSW/FTS/as-of → memcomparable → fjall.

KyzoScript compiles to relational algebra and evaluates with semi-naive, stratified, magic-set Datalog. Storage is fjall behind a memcomparable encoding — the invariant that lets relational, graph, vector, text, and time share one ordered store. Pure Rust end to end: embedded, server, or browser — no C/C++ in the build.

Not a petabyte warehouse. Not a distributed OLTP cluster. KyzoDB is for one body of knowledge that must answer as facts, graph, similarity, text, and history — consistently, accountably, in one place.

Status

Feature-complete for its scope and correctness-proven (serializable transactions, crash recovery, oracle-verified query semantics, shipped ::verify). Still pre-1.0: expect API churn; empty scoreboards do not belong on this page. See VERSIONING.md. The board is live status.

Origins

KyzoDB began as a fork of CozoDB by Ziyang Hu and the Cozo Project Authors. Full story and attribution: FORK.md.

Links

License

Multi-licensed; LICENSING.md is the authoritative map. Engine/hosts are MPL-2.0; agent tooling under .claude/ is BSL-1.1. See CONTRIBUTING.md.

About

A pure-Rust knowledge database combining relational facts, graph traversal, vector similarity, and temporal reasoning in one engine.

Topics

Resources

Contributing

Security policy

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Used by

Contributors

Languages