Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Redis command capability ledger

This report separates four claims that cannot be reduced to one coverage percentage: command-name availability, typed semantics, RESP wire support, and session/topology behavior. A typed name does not prove every option, reply shape, protocol form, or routing mode.

The machine-readable source is conformance/command-capabilities.json. Unverified fields are explicit backlog, not implied support.

Pinned provenance

  • Redis documentation version: 8.8
  • Redis documentation revision: ad12d9cd6d10
  • Pinned metadata entries: 554
  • Scoped command names: 506
  • Redis documentation metadata license: CC-BY-NC-SA-4.0 (separate from the Rust crates’ MIT/Apache-2.0 license)
  • Ordinary generation and CI are offline; each vendored metadata file is SHA-256 verified from the detail manifest. The manifest records both the upstream byte digest and the digest after documented trailing-whitespace normalization.

Availability dispositions

DispositionScoped namesMeaning
dedicated_api6Supported by a stateful or higher-level API, not a stateless builder.
intentionally_unsupported2Deliberately outside the client API contract.
internal_protocol2Issued internally by routing/session machinery.
raw_only8Available only through an explicitly routed raw command.
typed_builder488Dedicated typed Command implementation.

These counts describe availability only. They are not combined with semantic, wire, or operational verification into a headline score.

Scoped names without typed builders

CommandDispositionPublic APIRationale
ASKINGinternal_protocolredis_tower_cluster::ClusterConnection
redis_tower_cluster::MultiplexedClusterClient
Cluster redirect handling sends ASKING and the redirected command as one connection-local exchange; a standalone builder would make unsafe separation easy.
CLUSTER COUNT-FAILURE-REPORTSraw_onlyredis_tower_commands::RawCommandNode-local cluster administration remains an explicitly routed raw operation.
CLUSTER MIGRATIONraw_onlyredis_tower_commands::RawCommandRedis 8 cluster migration administration is not part of automatic client routing and must target a deliberate node.
CLUSTER MYSHARDIDraw_onlyredis_tower_commands::RawCommandThis node-local topology inspection command requires an explicitly selected cluster node.
CLUSTER SLOT-STATSraw_onlyredis_tower_commands::RawCommandThis node-local Redis 8.2 administration command is available through a deliberately routed raw request.
CLUSTER SYNCSLOTSraw_onlyredis_tower_commands::RawCommandCluster slot synchronization mutates node-local state and is intentionally not exposed as an ordinary routed builder.
JSON.DEBUG HELPraw_onlyredis_tower_commands::RawCommandJSON.DEBUG MEMORY has a typed builder; the module help variant is an operator-facing raw reply and remains raw-only.
PSUBSCRIBEdedicated_apiredis_tower::PubSubConnection
redis_tower::BinaryPubSubConnection
redis_tower_cluster::ClusterPubSubConnection
redis_tower_cluster::BinaryClusterPubSubConnection
Pattern subscription changes a dedicated socket into Pub/Sub mode and is owned by the streaming session API.
PSYNCintentionally_unsupported—Replication handshakes and replication-stream consumption are outside the request/response client contract.
PUNSUBSCRIBEdedicated_apiredis_tower::PubSubConnection
redis_tower::BinaryPubSubConnection
redis_tower_cluster::ClusterPubSubConnection
redis_tower_cluster::BinaryClusterPubSubConnection
Pattern unsubscription is part of the stateful Pub/Sub session and its acknowledgement stream.
READONLYinternal_protocolredis_tower_cluster::MultiplexedClusterClientBuilderReplica-read connections issue READONLY during connection setup so reconnects restore the state before routing reads.
READWRITEraw_onlyredis_tower_commands::RawCommandThe public cluster clients own their read-routing mode; ad hoc connection-state reversal is only available on an explicitly owned raw session.
SSUBSCRIBEdedicated_apiredis_tower::PubSubConnection
redis_tower::BinaryPubSubConnection
redis_tower_cluster::ShardedClusterPubSubConnection
redis_tower_cluster::BinaryShardedClusterPubSubConnection
Sharded Pub/Sub uses a dedicated standalone session or a slot-aware Cluster session that follows the channel slot’s owner.
SUBSCRIBEdedicated_apiredis_tower::PubSubConnection
redis_tower::BinaryPubSubConnection
redis_tower_cluster::ClusterPubSubConnection
redis_tower_cluster::BinaryClusterPubSubConnection
Subscription changes the connection protocol mode and is exposed through a dedicated streaming session rather than a stateless command builder.
SUNSUBSCRIBEdedicated_apiredis_tower::PubSubConnection
redis_tower::BinaryPubSubConnection
redis_tower_cluster::ShardedClusterPubSubConnection
redis_tower_cluster::BinaryShardedClusterPubSubConnection
Sharded unsubscription is owned by the dedicated standalone or slot-aware Cluster Pub/Sub session and its confirmation handling.
SYNCintentionally_unsupported—Legacy replication handshakes and replication-stream consumption are outside the request/response client contract.
TRIMSLOTSraw_onlyredis_tower_commands::RawCommandThis node-local cluster maintenance operation is deliberately excluded from automatic key routing.
UNSUBSCRIBEdedicated_apiredis_tower::PubSubConnection
redis_tower::BinaryPubSubConnection
redis_tower_cluster::ClusterPubSubConnection
redis_tower_cluster::BinaryClusterPubSubConnection
Unsubscription and its confirmations are part of the stateful Pub/Sub session.

Audited command semantics and operations

19/506 scoped names currently have a command-specific semantic or operational audit. The remaining rows are recorded as unverified in the machine ledger.

CommandSemanticsBinary inputsOptions / responseRouting / sessionEvidence
ASKINGnot_applicablenot_applicableOwned by redirect machinery rather than an application command.ASK target node; same connection and immediately followed by redirected command; One-shot connection state must not be separated from the redirected command.topology.cluster-redirect
AUTHverifiedpartialpassword or username/password; status; Prefer constructor credential configuration so reconnect restores authentication.connection-local; connection setup; Ad hoc AUTH does not mutate a connection factory.session.connection-setup
session.credential-provider
BLPOPverifiedverifiedone or more keys plus timeout; optional key/value pair; None on Redis timeout; Caller cancellation after write cannot prove that no element was delivered.same slot in Cluster; exclusive connection recommended; a multiplexed response deadline can fail a slow command and retire its worker; Standalone value and Redis-timeout replies are verified. Cluster routing and non-stalling concurrent isolation are not command-specifically verified here.command.blocking-dedicated
CLIENT TRACKINGpartialnot_applicableowned by caching clients; raw ad hoc variants are not replayed; status; Caching clients enforce their own tracking configuration and invalidation lifecycle.per data connection; connection-local tracking state; Tracking state is restored only by the caching client that owns it.session.client-tracking
EVALpartialverifiedkeys must be declared separately from arguments; raw Frame; The script defines the reply shape; applications must decode deliberately.all declared keys in one Cluster slot; stateless command; Declared-key encoding is verified in standalone differential tests; Cluster routing remains unaudited here.command.eval-declared-keys
FT.SEARCHpartialpartialFtSearch supports NOCONTENT, VERBATIM, WITHSCORES, LIMIT, RETURN and SORTBY; other documented options are not exposed by this builder; raw Frame; The separate high-level SearchClient::search API performs typed result deserialization. Both require the search Cargo feature and Redis Search server capability.module/topology dependent; stateless command; Module availability is proven separately from compilation.module.behavior-differential
GETverifiedverifiednone; Option<Bytes>; nil and empty values remain distinct; RESP2/RESP3 byte strings normalize to the same public shape.single key slot; stateless command; Read-only and idempotent.command.binary-and-scalar
topology.cluster-core-routing
HELLOverifiedpartialRESP version, optional auth and client name; server capability map; Prefer connection protocol configuration so reconnect repeats negotiation.connection-local; connection setup; Protocol version is a socket property.session.connection-setup
HGETALLverifiedverifiednone; Vec<(Bytes, Bytes)> parsed from RESP2 flat arrays or RESP3 maps; Binary fields and values are preserved; the public response is an ordered pair vector, not a map type.single key slot; stateless command; Large hashes can produce large replies.command.collection-stream-shapes
topology.cluster-core-routing
JSON.GETpartialverified for keysJSONPath and formatting grammar are textual; optional raw JSON bytes; Requires the JSON Cargo feature and RedisJSON server capability.single key slot; stateless command; Module capability and standalone behavior are verified; Cluster module routing is not audited here.module.behavior-differential
MGETverifiedverifiedone or more keys; ordered Vec<Option<Bytes>> preserving nil and empty entries; The result position corresponds to the input key position.same slot for atomic server command; explicit split helpers are non-atomic; stateless command; Standalone response order is verified; cross-slot split-helper order is verified separately, but same-slot Cluster MGET remains unaudited here.command.binary-and-scalar
topology.cluster-core-routing
MONITORverifiednot_applicablenone; stream of monitor lines; MONITOR permanently changes the socket mode until it is dropped.explicit server node; dedicated MonitorStream; No reconnect resume cursor; commands during a gap are lost.session.monitor-dedicated
session.credential-provider
SCANpartialpartialcursor, MATCH and COUNT are live-tested; TYPE is encoded by the builder but is not live-tested here; cursor plus a possibly empty page of binary keys; Continue until cursor zero; changing keyspaces can repeat elements.one selected node; use ClusterScan for all nodes; cursor sequence without connection affinity; A normal Cluster SCAN is not cluster-wide.command.scan-cursor
SELECTverifiednot_applicabledatabase index; status; Cluster does not support multiple logical databases.connection-local; connection setup; Configure the database in the connection factory for reconnect replay.session.connection-setup
session.credential-provider
SETpartialverifiedEX/PX, NX/XX and GET are typed; EXAT/PXAT/KEEPTTL and Redis 8.4 IFEQ/IFNE/IFDEQ/IFDNE are unimplemented; Set::with_outcome returns independent Applied/NotApplied status and NotRequested/Missing/Value previous-value state; base Set preserves the legacy Option<Bytes> response; RESP2/RESP3 live and parser coverage exercises ordinary SET plus all applied/rejected NX/XX branches with and without GET, including missing, empty and binary previous values. Expiry combinations are not covered.single key slot; stateless command; Non-idempotent option combinations are not replayed by typed retry policy.command.set-options
command.binary-and-scalar
topology.cluster-core-routing
SSUBSCRIBEverifiedverifiedone or more shard channels in one slot; subscription confirmations and message stream; Messages during a disconnect before server-side resubscription are not recovered.standalone server or current Cluster owner of the shared slot; dedicated standalone or sharded Cluster Pub/Sub connection; Cluster cross-slot subscription sets are rejected before dispatch.session.pubsub-reconnect
session.credential-provider
SUBSCRIBEverifiedverifiedone or more channels; subscription confirmations and message stream; Confirmed subscriptions can be replayed, but disconnected-gap messages are lost.explicit standalone or Cluster node; dedicated Pub/Sub connection; Not a stateless multiplexed command.session.pubsub-reconnect
session.credential-provider
WATCHverifiedverifiedone or more keys; status before EXEC commit/abort outcome; Use the Transaction abstraction for an already-built atomic exchange.same Cluster slot; dedicated connection for read/compute/write retry loops; A pool has no multi-call connection lease.command.pipeline-transaction
command.binary-and-scalar
topology.cluster-core-routing
XREADGROUPpartialpartialgroup, consumer, streams, IDs, COUNT and BLOCK; NOACK is not exposed by the builder; typed stream/entry vector for the tested non-blocking consumer-group lifecycle; The builder accepts byte-preserving CommandArg inputs, but the live XREADGROUP evidence uses text identifiers. Blocking timeout shape is not command-specifically verified here.same slot in Cluster; exclusive connection recommended when BLOCK is used; Standalone consumer-group behavior is verified; blocking isolation and Cluster routing remain unaudited here.command.stream-consumer-group

Wire protocol contracts

ContractStatusCurrent behaviorEvidence
configured-resource-limitssupportedFrame wire size, aggregate cardinality and nesting depth are preflighted before recursive frame materialization, independently of fragmentation.protocol.boundaries
protocol.fragmentation
fragmentation-equivalencesupportedWhole-buffer and arbitrarily fragmented decoding have the same semantic outcome and error category for the tested corpus.protocol.fragmentation
resp2-framessupportedRESP2 scalars, nulls and aggregates are decoded within configured size/depth limits.protocol.boundaries
protocol.fragmentation
resp3-core-framessupportedSupported RESP3 scalar and fixed aggregate forms are decoded and normalized by typed response parsers.protocol.boundaries
command.collection-stream-shapes
resp3-fixed-attributesrejectedFixed attributes fail closed without consuming bytes; attachment to the following value remains planned in issue #705.protocol.boundaries
resp3-streamed-formsrejectedStreamed string/aggregate headers, chunks and terminators fail closed rather than becoming independent replies; bounded assembly remains planned in issue #705.protocol.boundaries
protocol.fragmentation

Logical behavior evidence

A source test, a configured workflow selector, and a dated successful run are separate evidence states. A later checkout must use its own attached checks rather than inheriting the observed result below.

Behavior command binary and scalar

Logical ID: command.binary-and-scalar.

Raw RESP2/RESP3 scalar, nil, empty, binary and numeric replies are compared with redis-rs. Separate typed live tests verify byte-preserving builders and public GET/MGET decoding, including ordered nil-versus-empty results, under forced RESP2 and RESP3.

Behavior command blocking dedicated

Logical ID: command.blocking-dedicated.

Typed BLPOP returns a key/value pair when data is available and None after a Redis timeout on an exclusive connection. A separate multiplexed raw BLPOP test proves the configured response deadline returns CommandTimeout; the differential BLMOVE case is immediate because its source list is preloaded.

Behavior command collection stream shapes

Logical ID: command.collection-stream-shapes.

Raw hash, collection and Stream replies are compared with redis-rs using independent keys and controlled normalization. Separate typed live and parser tests verify HGETALL’s public pair-vector shape, empty response and RESP3 map normalization.

Behavior command eval declared keys

Logical ID: command.eval-declared-keys.

Typed EVAL preserves binary declared keys and arguments and matches redis-rs for the tested nested reply.

Behavior command pipeline transaction

Logical ID: command.pipeline-transaction.

Pipeline ordering and transaction commit/abort outcomes are compared with redis-rs without reusing mutating datasets.

Behavior command scan cursor

Logical ID: command.scan-cursor.

Standalone SCAN cursor iteration exercises MATCH and COUNT until cursor zero; Cluster tests prove a plain keyless SCAN reaches one node while ClusterScan covers the full keyspace.

Behavior command set options

Logical ID: command.set-options.

SET outcome mode distinguishes applied and rejected NX/XX writes independently from unrequested, missing, empty and binary previous values. RESP2/RESP3 parser and live tests cover the complete supported outcome matrix; NX+GET and XX+GET branches are also compared with redis-rs. Expiry combinations remain outside this behavior row.

Behavior command stream consumer group

Logical ID: command.stream-consumer-group.

A typed XREADGROUP call reads new entries in a standalone consumer-group lifecycle, after which typed pending, acknowledgement, claim and autoclaim operations verify ownership transitions.

Behavior module behavior differential

Logical ID: module.behavior-differential.

Module capability preflight is followed by RedisJSON/Search/TimeSeries/probabilistic/Vector behavior and selected redis-rs reply comparisons.

Behavior protocol boundaries

Logical ID: protocol.boundaries.

Independent wire fixtures prove frame limits, aggregate preflight, nesting limits and fail-closed handling for fixed attributes and streamed forms.

Behavior protocol fragmentation

Logical ID: protocol.fragmentation.

Property and fuzz oracles compare whole-buffer decoding with arbitrary fragmentation plans and stable error categories.

Behavior session client tracking

Logical ID: session.client-tracking.

Managed caching clients install tracking, invalidate external writes, reject unsafe connection-state commands and restore a lost redirect connection.

Behavior session connection setup

Logical ID: session.connection-setup.

Authentication, RESP negotiation and selected database state are exercised through connection setup and reconnect-aware paths.

Behavior session credential provider

Logical ID: session.credential-provider.

One shared credential provider backs fresh standalone and Cluster sockets plus dedicated Pub/Sub and MONITOR construction. Provider URL setup preserves transport, selected database and RESP negotiation; lookup, forced-refresh, transport and session setup can share one deadline. A forced-refresh failure is redacted and stops setup before SELECT, HELLO or application traffic. Established ordinary clients can reauthenticate through owned tasks with explicitly documented owner-specific failure retirement, while Pub/Sub reconnects with confirmed binary subscriptions and MONITOR terminates/reopens rather than accepting unsafe generic in-band AUTH. Provider errors and refresh-task tracing omit third-party error text and retain authentication classification.

Behavior session monitor dedicated

Logical ID: session.monitor-dedicated.

A dedicated MONITOR session parses streamed events and preserves binary command arguments while another connection executes the command.

Behavior session pubsub reconnect

Logical ID: session.pubsub-reconnect.

Dedicated regular and sharded Pub/Sub sessions preserve binary names, replay confirmed subscriptions and follow tested Cluster ownership changes.

Behavior topology cluster core routing

Logical ID: topology.cluster-core-routing.

Cluster live tests route binary single-key GET/SET, HGETALL, ordered non-atomic split MGET helpers and slot-pinned WATCH transactions through public APIs.

Behavior topology cluster redirect

Logical ID: topology.cluster-redirect.

Cluster clients keep ASKING with the redirected command, follow ASK then MOVED, and update slot ownership during a live reshard.

Offline validation and refresh

Validate references, dispositions, source builders, pinned file hashes, and generated output without network access:

python3 scripts/generate_command_capabilities.py --check
python3 scripts/generate_command_coverage.py --check

To review a newer Redis documentation snapshot, fetch an explicit commit into a separate directory and compare it before changing provenance:

python3 scripts/fetch_command_metadata.py --ref <redis-docs-commit> \
  --output-dir /tmp/redis-command-metadata
python3 scripts/generate_command_capabilities.py \
  --compare-metadata /tmp/redis-command-metadata

The comparison reports added/removed names and any command-definition change, including scope, routing keys/flags, arity, versions, summaries, history, and arguments/options. Updating the five vendored files, their hashes, and every new disposition is a reviewed repository change. The downstream MCP project’s Redis 8.10.1 application ledger has a different denominator and is not substituted for this client ledger.