KiviDB 1.1.0 release: Redis‑compatible Rust database with 9× Redis throughput and built‑in vector search
TL;DR
KiviDB 1.1.0 is a drop‑in Redis/Valkey replacement written in Rust that runs every CPU core, achieves 21 M pipelined GETs/s (≈9× Redis 8, 2.3× Dragonfly) on a 32‑core server, and includes built‑in Redis‑Stack‑style full‑text and vector search.
What KiviDB Is
KiviDB is a fast, multi‑threaded, in‑memory key‑value store that speaks the Redis protocol (RESP2 and RESP3). It can be used with any existing Redis client or redis-cli without code changes, and it adds native FT.* commands for full‑text, tag, numeric, and ANN vector queries (FLAT and HNSW).
- Protocol compatibility – all standard Redis commands work; see
COMMANDS.mdfor the supported subset. - Search integration –
FT.CREATE,FT.SEARCH,FT.HYBRID, etc., behave like Redis Stack. - Optional Lua and TLS – enabled via Cargo features
luaandtls. - Default listen port – 6380 (Redis defaults to 6379, so both can run side‑by‑side).
- License – AGPL‑3.0‑only; using KiviDB as a network service does not impose AGPL on your application.
Performance Highlights
All benchmarks were run in October 2026 on two AWS Graviton3 bare‑metal c7gn.metal instances (64 vCPU, 32 cores used for the server). Each engine was tested in isolation.
Key‑Value Throughput & Latency
| Operation | KiviDB 1.1.0 | Dragonfly 2.0.2 | Redis 8.10 | Redis Cluster (32 shards) |
|---|---|---|---|---|
| GET, pipelined ×16 | 21.2 M ops/s | 9.1 M | 2.4 M | 4.7 M |
| SET, pipelined ×16 | 19.2 M ops/s | 8.5 M | 2.0 M | 4.7 M |
| GET, no pipelining | 3.07 M ops/s | 3.35 M | 1.32 M | 1.46 M |
| SET, no pipelining | 3.12 M ops/s | 3.38 M | 1.54 M | 1.46 M |
| p99 latency (GET/SET, pipelined ×16) | 0.36 ms / 0.42 ms | 0.88 ms / 1.07 ms | 2.2 ms / 2.7 ms | – |
| Memory per key | 177 B | 134 B | 178 B | 183 B |
KiviDB’s sharded, per‑core design enables every core to serve requests, unlike Redis’s single‑threaded I/O model.
Vector Search (ANN) Performance
Benchmarks used the redis/vector-db-benchmark suite on a 1.18 M‑vector, 25‑dimensional Glove dataset (HNSW, M=16, EF_CONSTRUCTION=256). 100 client threads uploaded batches of 64 vectors, then issued queries at various ef values.
| Metric | KiviDB 1.1.0 | Dragonfly 2.0.2 | Redis 8.10 (query engine) |
|---|---|---|---|
| Queries/s (ef = 64, recall@10) | 59.3 k (0.943) | 41.3 k (0.912) | 31.8 k (0.912) |
| Queries/s (ef = 128) | 50.7 k (0.961) | 40.3 k (0.937) | 28.9 k (0.937) |
| Queries/s (ef = 256) | 31.5 k (0.989) | 36.2 k (0.979) | 21.1 k (0.979) |
| Queries/s (ef = 512) | 18.7 k (0.998) | 29.8 k (0.995) | 13.7 k (0.995) |
| Ingest & index build time | 31 s | 13 s | 38 s |
| Memory after ingest | 1.66 GB | 1.13 GB | 1.07 GB |
KiviDB excels at high‑recall queries with lower
efvalues, while Dragonfly builds the index faster and uses less memory.
Core Architectural Advantages
- Sharded per‑core design – each worker thread owns a disjoint keyspace slice, eliminating lock contention and enabling true parallelism.
- Rust safety & performance – compiled with the 2024 edition, leveraging
io_uringwhen available (fallback to Tokio). - Built‑in search – no external module required;
FT.*commands are part of the core binary. - Persistence options – snapshot (
dump.kdb) and optional Append‑Only File (AOF) for near‑real‑time durability.
Quick Start Guide
# Pull the official Docker image (default variant)
docker run -d -p 6380:6380 kividb/kividb
# Verify the server is alive
redis-cli -p 6380 PING # → PONG
Creating a Vector Index (Redis‑Stack syntax)
redis-cli -p 6380 FT.CREATE idx ON HASH PREFIX 1 doc: \
SCHEMA vec VECTOR HNSW 10 TYPE FLOAT32 DIM 128 \
DISTANCE_METRIC COSINE M 16 EF_CONSTRUCTION 128
Storing a Vector
Store raw little‑endian FLOAT32 bytes in a hash field (e.g., HSET doc:1 vec <binary>). The format matches Redis Stack and redis-py/NumPy blobs.
KNN Query (Dialect 2)
redis-cli -p 6380 FT.SEARCH idx '*=>[KNN 10 @vec $q]' \
PARAMS 2 q <binary‑blob> DIALECT 2
Full command reference is in COMMANDS.md.
Persistence Details
- Snapshots (
dump.kdb) capture keys, index schemas, and the HNSW graph whenSAVE/BGSAVEis executed after indexing. - AOF (
--aof) appends every write; on restart the AOF is replayed and becomes the source of truth, bypassing snapshot loading. - During index rebuild at startup most commands return
LOADINGuntil the graph is ready;PINGandINFOremain functional.
Build Variants
| Variant | Cargo features | What it adds |
|---|---|---|
default |
none | Core server only |
lua |
lua |
Lua scripting (EVAL, SCRIPT, …) |
tls |
tls |
TLS listener and intra‑node TLS |
full |
lua,tls |
Both Lua and TLS |
Example builds:
cargo build --release # default
cargo build --release --features lua # with Lua
cargo build --release --features tls # with TLS
cargo build --release --features lua,tls # full
Linux builds automatically use io_uring when the kernel permits; otherwise they fall back to Tokio (--io-model auto).
Configuration Highlights
Key flags (defaults in parentheses):
--port 6380– listening port.--bind 0.0.0.0– address; setting this disables protected mode.--protected-mode yes– on by default; only loopback clients are allowed unless a password or bind address is configured.--threads 0– auto selectscores‑2(minimum 2).--aof– enable Append‑Only File persistence.--maxmemory 0– unlimited memory; set to enforce a cap.--cluster-enabled no– optional cluster mode with a separate bus onport+10000.- TLS options (
--tls-port,--tls-cert-file, etc.) are available when built with thetlsfeature.
All flags can be supplied via a Redis‑style config file (/etc/kividb/kividb.conf by default) or command‑line; command‑line overrides file values.
Docker Usage
# Pull the latest image (default variant)
docker pull kividb/kividb:latest
docker run -p 6380:6380 kividb/kividb
- The container runs with
--protected-mode noby default because Docker exposes the network externally. Pass your own flags to re‑enable protected mode and set a password. - For AOF persistence:
docker run -p 6380:6380 \
-v $(pwd)/data:/home/kividb \
ghcr.io/kividbio/kividb \
--aof --requirepass "change-me"
- To allow
io_uringinside Docker, add--security-opt seccomp=unconfined(understand the security implications before production use).
Community Feedback (Hacker News)
- Benchmark reproducibility – the author shared the
kivi-benchmarkrepo containing Terraform scripts and load‑generator code for independent verification. (Comment by @murtazayusuf) - Load‑generator limits – a commenter noted that achieving >5 M ops/s often requires multiple load‑generator hosts; KiviDB’s reported 21 M ops/s likely reflects the server’s capacity rather than client bottlenecks. (Comment by @falconBrisk47)
- Feature comparison requests – users asked for Valkey benchmarks and a comparison with Apache KVrocks; these are not present in the current release notes.
- AI involvement – the maintainer confirmed extensive AI assistance in design decisions, but the core engineering was human‑driven. (Comment by @ghm2180)
- Memory footprint – a question about memory usage during ingestion remains unanswered; the published tables show per‑key memory (177 B) and post‑ingest vector memory (1.66 GB for 1.18 M vectors).
Licensing and Commercial Options
KiviDB is released under AGPL‑3.0‑only. Running an unmodified KiviDB as a network service does not impose AGPL obligations on your proprietary application. If you modify KiviDB itself and provide it as a hosted service, you must make the modified source available to your users.
For organizations that cannot accept AGPL terms, KIVIDB PRIVATE LIMITED offers a commercial license. Inquiries can be sent to support@kividb.io.
Where to Get It
- GitHub repository – https://github.com/kividbio/kividb
- Docker Hub / GHCR –
kividb/kividb:latest(alsov1.1.0,v1.1.0-lua,v1.1.0-tls,v1.1.0-full) - Release binaries – Linux x86_64, Linux aarch64, macOS (Intel & Apple Silicon) tarballs; Debian/ RPM packages are also provided.
- Benchmark suite – https://github.com/kividbio/kivi-benchmark for reproducing the performance numbers.
Quick Reference Commands
# Start server (default variant)
./kividb
# Start with TLS (requires `tls` feature)
./kividb --port 6380 --tls-port 6381 \
--tls-cert-file cert.pem --tls-key-file key.pem
# Enable AOF persistence
./kividb --aof --requirepass "s3cr3t"
# Run in cluster mode
./kividb --cluster-enabled yes --cluster-node-timeout 15000
All benchmark figures are snapshots of a single controlled environment; real‑world performance will vary based on hardware, workload, and configuration.