Redis

Editor’s note: This Redis review is based on my hands-on test of Redis Cloud (the Free and Essentials plans) and Redis Open Source 8.8, in November 2026. I weighed RAM-based pricing, setup, vector search, vector sets, Redis Iris, licensing, and rivals such as Pinecone and pgvector.

Quick verdict: I recommend Redis for teams that already run it as a cache and want vector search, semantic caching and agent memory without a separate vector store. The trade-off is RAM-based sizing: one million replicated 1,536-dimension embeddings outgrow Essentials’ 12 GB and land on Pro’s $200 monthly minimum.

Redis 8 folded the Query Engine, JSON and time series into core Redis and added vector sets plus an AGPLv3 option, so no vector command I ran for this Redis review needed a separate module.

In this Redis review, I’ll take a closer look at Redis’s pricing, vector search features, and agent tooling, so you can see exactly whether it should be the vector database in your AI stack.

Key Takeaways:

• Redis Cloud runs from a free 30 MB database to Essentials at $5 a month for 250 MB and Pro’s $200 monthly minimum.
• FT.HYBRID (Redis 8.4+) fuses full-text and vector results in one command.
• On Essentials, Redis Search requires a RAM plan because Essentials Flex has none; Pro’s Flex search is still a beta.
• Redis Iris bills $0.05 per 1M retrieval tokens, with Agent Memory’s first 5,000 messages free.
• Stock Redis Open Source lacks Intel’s LVQ and LeanVec compression.

Pros and Cons

Redis Pricing: How Much Does Redis Cost?

Redis Cloud pricing is set by database memory size, replication and persistence, not by queries or vectors.

• Free ($0): for learning and prototypes; one shared 30 MB database per account with 100 ops/sec, 5 GB monthly bandwidth, a best-effort SLA and community support, but no high availability or backups.
• Essentials (from $5/month): for small production apps; one database with 250 MB to 12 GB of RAM at $5 to $175 a month in US East without replication, or $258 for 12 GB with multi-zone replication and persistence. It adds 1,000 to 16,000 ops/sec, SAML SSO, RBAC, encryption at rest, backups, up to 99.99% uptime and basic support.
• Essentials with Redis Flex (from $5/month for 1 GB): for large caches on a budget; RAM plus SSD up to 100 GB ($500 a month, $600 with persistence) on AWS only, with no Redis Search.
• Pro (from $0.014/hour, $200/month minimum): for production AI workloads; dedicated deployment, unlimited RAM, multiple databases, active-active, private connectivity, Redis Search with the Query Performance Factor, Redis Data Integration, up to 99.999% uptime and a 24/7 support hotline. The plan card carries a “First $200 free” badge.
• Redis Software (custom quote): for self-managed clusters on-prem or in your own cloud; priced through sales.
• Redis Open Source ($0): for self-hosting Redis 8.8 under RSALv2, SSPLv1 or AGPLv3.

Redis Iris meters sit on top of the database: $0.05 per 1M retrieval tokens, $1 per 1M processing tokens, $0.0018 per message and $5 per 1M tool calls.

Plan	Price	Memory	Throughput / SLA	Vector search
Free	$0	30 MB	100 ops/sec; best-effort	Not listed
Essentials	$5 to $258/month (US East)	250 MB to 12 GB RAM	1,000 to 16,000 ops/sec; up to 99.99%	Yes
Essentials Flex	$5 to $600/month	1 GB to 100 GB RAM plus SSD	200 to 20,000 ops/sec	No
Pro	From $0.014/hour, $200/month minimum	Unlimited RAM	Configurable; up to 99.999%	Yes, plus Query Performance Factor; Flex beta
Redis Software	Custom	Deployment-dependent	Deployment-dependent	Yes, horizontal search scaling
Redis Open Source	$0	Host-dependent	Self-managed	Yes, single node

Is Redis Good Value for Money?

• Embedding size sets the plan. By my approximate arithmetic, a 1,536-dimension FLOAT32 embedding is 6,144 bytes, so 1M of them is about 6.1 GB of raw vectors before HNSW links and metadata; 768 dimensions halve that to about 3.1 GB.
• Replication counts against Essentials. A replicated 1M x 1,536 index does not fit the 12 GB plan, which pushes it to Pro and its $200 monthly minimum.
• The minimum sets Pro’s entry price. Pro’s $0.014 an hour is about $10 a month, so the $200 floor is the real cost of entry.
• Flex is cheaper but cannot search. 12 GB costs $60 a month on Flex versus $175 in RAM, where vector workloads must stay.
• Pinecone wins on cold storage. Its Standard plan charges $0.33 per GB a month for storage, with a $50 monthly minimum, so a large, rarely queried index costs less there; Redis wins when the same database also serves cache and session traffic.

Reviewer’s Notes: I recommend Essentials at 1 GB to 5 GB ($18 to $110 a month in US East, depending on replication and persistence) for a prototype or a few hundred thousand vectors. Move to Pro once the index plus replication passes 12 GB or search needs the Query Performance Factor. Keep Essentials Flex for non-search data only.

My Experience With Redis

Creating My Redis Cloud Database

I signed up for Redis Cloud with the form (Google and GitHub sign-up are also offered), activated the account from the email, and landed on Create database with the Free plan preselected. I picked the database version, a cloud vendor (AWS, Google Cloud or Azure) and a region, then selected Create database. The status icon showed a pending clock until the database turned active with a green check.

To connect, I revealed the default user’s password under Security and opened the Connect wizard, which offers Redis Insight, redis-cli or a client library. Client libraries include redis-py, RedisVL, Jedis, Lettuce, node-redis, go-redis and NRedisStack. I opened Redis Insight in the browser, where it offered Load sample data; the web version works only for Essentials databases, so Pro databases need the installed app.

Each account gets one free database, and the plan comparison lists Redis Search on Essentials and Pro, not on Free. So I created a 250 MB Essentials database at $5 a month for the vector index, which also raised the throughput cap from 100 to 1,000 ops/sec and added encryption at rest and backups.

Pinecone’s free Starter includes 2 GB of storage and Qdrant’s free cluster 1 GB of RAM, both with vector search on the free tier, against a 30 MB Redis Free database with no search listed.

Building My First Vector Index

I created the index with FT.CREATE over hashes with a docs: prefix, defining a VECTOR field as HNSW, TYPE FLOAT32, DIM 1536 with DISTANCE_METRIC COSINE. I stored each embedding with HSET as raw bytes, since the blob size must match DIM and TYPE. Then I queried with FT.SEARCH using a KNN clause, passed the query vector as a PARAMS blob, ordered results with SORTBY on the score field and set DIALECT 2, which vector queries require.

The default LIMIT is 10, so a KNN 50 query returns only 10 rows unless it also passes LIMIT 0 50. I paired every top-k above 10 with a matching LIMIT.

I added TAG and NUMERIC fields to the same index, so a category or price filter narrows the KNN search in the same query. Redis picks between batch filtering and brute force depending on how selective the filter is.

I kept the HNSW defaults of M 16, EF_CONSTRUCTION 200 and EF_RUNTIME 10. Raising M buys recall at the cost of memory and build time, which on Redis means a bigger RAM bill; EF_RUNTIME can also be raised per query to tune recall.

Trying Vector Sets

For a schema-free lookup, I added vectors with VADD, which applies Q8 quantization by default, attached JSON attributes with VSETATTR, and queried with VSIM plus a FILTER expression for size equal to large and price above 20. There was no FT.CREATE schema or index definition to write, and the REDUCE option applies random projection to cut dimensions.

Best for: developers comfortable with Redis commands. Skip if: you want a console that builds and tunes vector indexes for you.

Vector Search in the Redis Query Engine

The Redis Query Engine offers three vector index types: FLAT for exact search (advised under 1M vectors), HNSW for approximate search over larger sets, and SVS-VAMANA, added in Redis 8.2.

• Data types: FLOAT32, FLOAT64, FLOAT16, BFLOAT16, INT8 and UINT8 for FLAT and HNSW; SVS-VAMANA takes FLOAT16 or FLOAT32 only.
• Distance metrics: L2, inner product (IP) and COSINE.
• Storage: hashes hold raw vector bytes; JSON documents hold float arrays and support multi-value indexing.
• Queries: KNN, vector range queries, and filtered KNN with TEXT, TAG, NUMERIC and GEO fields.
• Hybrid: FT.HYBRID (Redis 8.4, GA November 25, 2025) fuses full-text and vector results with Reciprocal Rank Fusion or a linear combination; Redis 8.8 (GA May 2026) added a KNN argument to request fewer candidates per shard.

SVS-VAMANA supports six compression options (LVQ8, LVQ4, LVQ4x4, LVQ4x8, LeanVec4x8 and LeanVec8x8), but Intel’s LVQ and LeanVec are not in the stock Redis Open Source build. There, compression falls back to 8-bit scalar quantization; the AGPLv3 and SSPLv1 builds cannot be combined with Intel’s optimization binaries, which are usable with an RSALv2 build compiled with Intel’s flag or through Redis’s commercial products, Redis Cloud and Redis Software. Learned compression can also degrade as the data drifts.

In a cluster, each shard holds its own index. SHARD_K_RATIO (0.1 to 1.0, default 1.0) tunes how many candidates each shard returns, and unbalanced shards can return fewer than the requested top-k results. Redis publishes no hard maximum vector dimension.

Pro Flex search needs a console beta flag and supports FLAT and HNSW vector fields, but not JSON documents, NUMERIC or GEO fields, FT.AGGREGATE, FT.HYBRID or background indexing yet. Zilliz Cloud prices tiered-storage clusters per million vectors, from $5 per million a month, where Redis pays RAM for every vector.

The verdict: Redis vector search is production-grade for filtered KNN and hybrid retrieval, priced in RAM. I recommend it when FT.HYBRID and metadata filters matter more than storage cost per vector.

Vector Sets: The Simpler Way to Store Embeddings

Vector sets are a native Redis 8 data type created by Redis’s original author, Salvatore Sanfilippo. Each set is an HNSW graph: VADD writes vectors and VSIM runs similarity lookups without an FT.CREATE schema.

• Q8: the default, 4x smaller than FP32 with high recall; a 300-dimension vector drops from 1,200 to 300 bytes.
• BIN: 32x smaller and the fastest mode, with lower recall.
• NOQUANT: full size, the highest recall and the slowest mode.

REDUCE applies random projection to cut dimensions, and JSON attributes set with VSETATTR feed VSIM FILTER expressions, such as a minimum price. Large vectors, a high M and bulky JSON attributes drive memory, and DEL on a large vector set can briefly spike latency while HNSW links are reclaimed. Keep attributes flat and minimal, and lower M or apply REDUCE when memory climbs.

Redis 8.8.2 (August 2026) fixed three vector-set memory-safety bugs, so run 8.8.2 or a later release rather than an earlier 8.8 build.

Quick comparison: vector sets skip hybrid text search and FT.AGGREGATE aggregations, so pick FT.CREATE and the Query Engine when you need FT.HYBRID or full-text fields, and vector sets for simple similarity lookups.

Redis Iris: Agent Memory, Semantic Caching and Intent Routing

Redis Iris groups six agent services sold on usage meters on top of a Redis database. Iris first launched in May 2026; the November 4, 2026 release made Intent Router, Agent Playbooks, Agent Memory and Context Gateway generally available, with Lens and Agent Mesh in beta.

• Agent Memory: session memory (ordered events, TTL, automatic summarization) plus long-term memories extracted in the background with vector embeddings, through the redis-iris Python SDK, iris CLI, REST API or MCP server. It bills $0.05 per 1M retrieval tokens, $1 per 1M processing tokens and $0.0018 per message, first 5,000 messages free.
• Agent Playbooks: the semantic cache Redis previously sold as LangCache, now with reusable FAQs and skills over a REST API. It bills $0.05 per 1M retrieval tokens, plus processing and per-message fees only when its learning loop is on (off by default).
• Intent Router: routes a request by meaning to an FAQ, an agent skill, a human or an LLM, at $0.05 per 1M retrieval tokens only.
• Context Gateway: one MCP endpoint in front of your MCP servers, data sources and APIs, with tool caching, at $5 per 1M tool calls.
• Lens: free in beta; traces outcomes to a skill, route, FAQ, memory or session, with tokens per task and latency.
• Agent Mesh: beta; agent streams with auto-buffering and reconnect, plus agent-to-agent handoffs.

Iris charges no seats and no per-agent fees. Tokens are counted only on what end users send (o200k_base tokenizer), and the Redis database holding memories and cached answers is billed on its own plan.

Iris runs managed on Redis Cloud Essentials or Pro, or self-managed on Kubernetes through one Helm release. Set Agent Memory’s custom memory types and sensitive-data exclusions before it stores conversation history.

Best for: teams adding memory and semantic caching to Redis-backed agents. Skip if: you only need nearest-neighbor retrieval, which Pinecone or Qdrant handle without separate agent meters.

Open Source vs Redis Cloud vs Redis Software: Licensing and Scaling

Redis Open Source from Redis 8 ships under a choice of RSALv2, SSPLv1 or AGPLv3. Only AGPLv3 is OSI-approved; RSALv2 and SSPLv1 are not open source licenses.

• Through Redis 7.2: BSD.
• March 2024: RSALv2 and SSPLv1 only, from Redis 7.4.
• March 28, 2024: Valkey forked Redis 7.2.4 under BSD-3-Clause at the Linux Foundation, backed by AWS, Google Cloud and Oracle.
• May 1, 2025: Redis added AGPLv3 as an option with Redis 8.

Redis Software, the self-managed commercial edition for on-prem or your own cloud, adds over Redis Open Source:

• Storage and ingestion: Redis Flex SSD tiering and Redis Data Integration.
• Availability: active-active geo-distribution, built-in high availability and disaster recovery.
• Cluster management: automated scaling, resharding and rebalancing.
• Search compute: horizontal search scaling with the Query Performance Factor.
• Access and support: centrally managed RBAC, LDAP, HashiCorp Vault support and enterprise support.

Search scaling beyond one node is commercial: Redis Cloud Pro sells it as a managed service. Redis Software is priced through sales, multi-cloud or hybrid Redis Cloud deployments need an annual plan, and both commercial editions are proprietary.

AGPLv3 is copyleft, not a return to BSD, so teams that modify Redis and offer it to others over a network should have counsel check their obligations. Valkey stays BSD, and Amazon ElastiCache for Valkey 9.0 (GA May 5, 2026) includes vector, full-text and hybrid search at no extra cost beyond standard ElastiCache pricing.

Direct recommendation: pick Redis Open Source for a single self-managed search node, Redis Cloud Pro for managed search scaling, and Redis Software when commercial operations must run in your own infrastructure.

How Does Redis Compare to Competitors?

• Pinecone: closed source and serverless; free Starter with 2 GB of storage, Builder at $20 a month flat, and Standard with a $50 monthly minimum and storage at $0.33 per GB a month. It fits teams that want a managed vector store with disk-priced storage and no cluster sizing.
• Qdrant: open source, with a free forever cluster (0.5 vCPU, 1 GB RAM, 4 GB disk), usage-based hourly billing, and Hybrid Cloud and Private Cloud options. It fits teams that want a dedicated open-source vector database they can also self-host.
• Weaviate: free sandbox (100K objects, 1 GB memory), Flex from $45 a month and Premium from $400 a month, with dimension pricing from $0.00465 per 1M dimensions on Flex. It fits teams that want a dedicated open-source engine priced by dimensions.
• Zilliz Cloud: managed Milvus with a free tier of 5 GB storage and 5 collections, and Dedicated from $126 a month. It fits large collections that can sit on tiered storage, from $5 per million vectors a month.
• pgvector: free open-source Postgres extension with HNSW and IVFFlat indexes and indexed vector columns up to 2,000 dimensions (halfvec up to 4,000). It fits teams whose source of truth is already Postgres.
• Valkey / Amazon ElastiCache: the BSD fork of Redis 7.2.4; ElastiCache for Valkey 9.0 adds vector, full-text and hybrid search at no extra cost. It fits AWS teams that want Redis-compatible caching plus search without Redis licensing.
• Upstash Vector: free tier with 10,000 daily queries or updates and 1 GB, then $0.40 per 100,000 requests on pay as you go. It fits serverless apps with spiky, low-volume traffic.

Redis wins where the same database already handles cache and session traffic and the vector set fits comfortably in RAM. If Redis would be a new system just for vectors, Pinecone’s $0.33 per GB storage or Zilliz Cloud’s tiered clusters cost less to hold a large, cold index.

For a broader database decision, see my Redis vs MongoDB comparison.

How I Reviewed Redis

For this Redis review, I created a Free database and a 250 MB Essentials database on Redis Cloud, connected through Redis Insight, built an HNSW index with TAG and NUMERIC filters, and ran KNN and hybrid queries. I tried vector sets with Q8 quantization and attribute filters, worked through the Redis Iris services and meters, compared the three editions and their licenses, and sized a 1M-vector index against each plan. My evaluation weighed:

• Pricing and value: RAM plans, replication and the Pro minimum.
• Setup: console flow and command requirements.
• Vector search: indexes, filters, hybrid queries and compression.
• Agent tooling: Iris services and meters.
• Scaling and licensing: the free build versus the commercial editions.
• Alternatives: the seven rivals compared above.

Prices current as of November 2026.

Should You Use Redis as Your Vector Database?

Yes, if you already run Redis (or need its caching anyway), your embeddings fit in RAM with replication, and you want filtered and hybrid vector search, a semantic cache and agent memory next to your cache and session data.

Skip it if you need a large, rarely queried index priced on disk (Pinecone, Zilliz Cloud), want an open-source dedicated vector database you can scale yourself (Qdrant, Weaviate), keep your data in Postgres (pgvector), or want BSD-licensed Redis compatibility on AWS (Valkey on ElastiCache).

Pick Essentials RAM while the index plus replication stays under 12 GB, and Pro beyond that or when search needs the Query Performance Factor. Essentials Flex is no cheaper home for vectors, since it has no Redis Search, and Pro Flex search still lacks FT.HYBRID.

Before committing, multiply vector count x dimensions x 4 bytes for FLOAT32, double it for replication, and add HNSW links and metadata. Check that total against the 12 GB Essentials ceiling, and put Pro’s $200 minimum in the budget if it lands above.

Start with a free database at Redis, then move to a 250 MB Essentials database at $5 a month for the vector index.

FAQ

Is Redis a vector database?

Yes. Redis 8 includes the Redis Query Engine with FLAT, HNSW and SVS-VAMANA vector indexes, filtered KNN and FT.HYBRID, plus vector sets as a native data type. These run in Redis Open Source, Redis Cloud and Redis Software. On Redis Cloud, Redis Search is listed on Essentials RAM and Pro plans, not on Free or Essentials Flex.

Is Redis free?

Redis Open Source 8.8 is free to self-host under RSALv2, SSPLv1 or AGPLv3. Redis Cloud Free gives one 30 MB database per account with a 100 ops/sec cap and no persistence, backups or high availability. Paid Essentials starts at $5 a month for 250 MB, the cheapest Redis Cloud plan that lists Redis Search.

Is Redis open source again?

Yes. From Redis 8 you can choose AGPLv3, an OSI-approved license, alongside RSALv2 and SSPLv1, which are not open source licenses. Redis 7.4 and later 7.x releases shipped under RSALv2 and SSPLv1 only, while Redis 7.2 and earlier used BSD. AGPLv3 is copyleft, so Valkey remains the BSD-licensed fork for teams that want permissive terms.

How much RAM do I need for 1 million vectors in Redis?

By my approximate arithmetic, about 6.1 GB of raw vectors for one million 1,536-dimension FLOAT32 embeddings, or about 3.1 GB at 768 dimensions. HNSW links and metadata add to that, and replication doubles it, so the replicated 1,536-dimension index outgrows the 12 GB Essentials plan. On Pro, add the estimated index size to the dataset size. INT8 vectors or Q8 vector sets cut the vector bytes.

What happened to Redis LangCache?

Its semantic cache now ships as Agent Playbooks inside Redis Iris, with reusable FAQs and skills over a REST API. Agent Playbooks became generally available in the November 4, 2026 release and bills $0.05 per 1M retrieval tokens, plus processing and per-message fees only when its learning loop is on. See the Redis Iris section above for every meter.