hotkv>COMMAND LIST

Built into HotKV™

Built in, not bolted on.

HotKV speaks the Redis protocol and adds features of its own. Pick any of them below and watch an animated example of it working, with the real commands.

protocol
RESP2 + RESP3
native code
C++20
Linux servers
x86_64 + ARM64
modules to install
0
Feature lab

See every feature work

Choose a feature. The demo types real HotKV commands with example replies, and shows what each one does inside the engine.

Key Tagging

Label keys with tags and query them: TAG.SET, TAG.GET, TAG.MEMBERS, TAG.INTER, TAG.COUNT, TAG.EXISTS, TAG.REM. No secondary index, no Lua script, no external service.

Keys get labels, and one command finds every key with a label, or with several labels at once.

Example session
hotkv> MSET user:1 a user:2 b user:3 c user:4 d
OK
hotkv> TAG.SET user:1 premium eu
(integer) 2
hotkv> TAG.SET user:2 premium us
(integer) 2
hotkv> TAG.SET user:3 eu
(integer) 1
hotkv> TAG.INTER premium eu
1) "user:1"
hotkv> TAG.MEMBERS eu
1) "user:1"
2) "user:3"
hotkv> TAG.COUNT user:1
(integer) 2
Architecture

Three ways to use a multi-core server

A server can execute commands on one main thread, split its data into a shard per thread, or let every thread work on one shared store. HotKV is built from scratch around the third design, so a single instance uses every core.

Single main thread
waitingT0T1T2T3one shared storeexecuting commandsnetwork I/O (I/O threads, when enabled)
I/O model
Event loop + I/O threads for read/write
Scaling
Diminishing returns beyond I/O saturation
Multi-core utilization
Commands run on one thread; more cores need several instances or a cluster
Shard per thread
T0T1T2T3S0S1S2S3a shard per threadmulti-key command crosses threads
I/O model
io_uring / epoll per thread
Scaling
Scales across cores; multi-key commands coordinate across threads
Multi-core utilization
Internal sharding per thread
HotKV · Shared store, every thread
T0T1T2T3one shared storeexecuting commands
I/O model
Multi-threaded, on every core
Scaling
Throughput scales with core count
Multi-core utilization
Single instance uses all cores

A schematic of how commands are executed, not a benchmark. Measured results are on the Performance page. Performance

Multi-threaded from the ground up

Each worker thread reads, parses and executes its own connections' commands, so I/O and execution both run in parallel and throughput grows with core count.

Predictable latency

A native engine with no garbage collector, so there are no stop-the-world pauses.

Modern C++20

HotKV is written in C++20 and compiled to native code.

Built for Linux servers

Packages for x86_64 and ARM64 Linux. Vector search uses the CPU's vector instructions where they are available.

Feature Comparison

How HotKV™ compares with Redis, Valkey, and Dragonfly, checked against each project's latest release.

FeatureHotKVRedisValkeyDragonfly
DeploymentHotKV Cloud or on-premiseSelf-managed or Redis CloudSelf-managed or managed by cloud providersSelf-managed or Dragonfly Cloud
LicenseCommercialRSALv2 / SSPLv1 / AGPLv3BSD-3-ClauseBSL 1.1
LanguageC++20CCC++
Command executionMulti-threadedSingle-threaded (optional I/O threads)Single-threaded (I/O threads)Multi-threaded
ProtocolRESP2 + RESP3RESP2 + RESP3RESP2 + RESP3RESP2 + RESP3
Server platformsLinux (x86_64, ARM64)Linux, macOS, BSDLinux, macOS, BSDLinux (x86_64, ARM64)
TLSYesYesYesYes
PersistenceSnapshots + AOFRDB + AOFRDB + AOFSnapshots only
Fork-less snapshotsYesNoNoYes
LLM prompt cacheYesSeparate service (LangCache)NoNo
Semantic cache for LLM responsesYesSeparate service (LangCache)NoNo
AI agent memoryYesSeparate service (Agent Memory)NoNo
RAG pipeline (chunking + hybrid search)YesHybrid search, no chunkingModule, no chunkingVector search, no chunking
LLM token and cost trackingYesNoNoNo
Vector similarity searchYesYesModule (valkey-search)Yes
Per-command latency histogramsYesYesYesPartial (opt-in percentiles)
Hot key detectionYesServer-side HOTKEYS commandClient-side onlyPartial (sampling)
Built-in Prometheus endpointYesNoNoYes
In-memory value compressionOpt-inNoNoNo
Key taggingYesNoNoNo
Nanosecond TTLYesNoNoNo

Compared with Redis 8.10.2, Valkey 9.1.2, and Dragonfly 2.0.0, the latest releases in September 2026. Redis 8 also ships JSON, time series, and probabilistic data structures, and Redis offers LangCache and Agent Memory as separate services. Valkey 9.2, now a release candidate, adds server-side hot key tracking and opt-in fork-less snapshots. On HotKV Cloud, the AI features come with the Performance and Scale plans.

Works With Your Stack

HotKV™ speaks RESP2 and RESP3, so the Redis client library you already use connects to it. Point it at your HotKV hostname.

Compatible Tools

Standard Redis tools connect without changes (see the command reference for the commands HotKV supports)

redis-cli
Official Redis CLI connects directly to HotKV
redis-benchmark
Standard benchmark tool
memtier_benchmark
Latency and throughput testing; our benchmarks use it
Prometheus
Built-in /metrics endpoint, no exporter needed
Grafana
Dashboards on the Prometheus metrics
HotKV SDKs
Official libraries with the AI commands built in