r/redis • • May 01 '25

News Redis 8 is now GA

Thumbnail
redis.io
43 Upvotes

Lots of features that were once part of Redis Stack are now just part of Redis including:

  • JSON

  • Probabilistic data structures

  • Redis query engine

  • Time series

Redis 8 also includes the brand new data structure—vector sets—written by Salvatore himself. Note that vector sets are still in beta and could totally change in the future. Use them accordingly.

And last but certainly not least, Redis has added the AGPLv3 license as an option alongside the existing licenses.

Download links are at the bottom of the blog post.


r/redis • • May 05 '25

News Redis is now available under the the OSI-approved AGPLv3 open source license.

Thumbnail
redis.io
21 Upvotes

r/redis • • 3d ago

Discussion I built a VS Code panel for Docker, K8s, Postgres, Kafka and Redis because I was tired of juggling 5 tools

Post image
1 Upvotes

I kept switching between Docker Desktop, a DB client, a Kafka UI and a terminal just to see what my local stack was doing, so I built a Services panel that sits next to Terminal and Ports.

What it does:

- Docker & Compose: containers, logs, shell, live CPU/memory charts

- Kubernetes: pods, logs, shell, port forwards

- Postgres, Cassandra, ScyllaDB: browse tables, query with completion

- Kafka: follow a topic like a log, consumer group lag

- Redis/Valkey/KeyDB/Dragonfly: keys by prefix, console

- SSH hosts: one click to a terminal

Databases and brokers running in Docker or Kubernetes show up automatically. It's free, has no telemetry and needs no account, and passwords go in your OS keychain.

It's early, so I'd really like blunt feedback: what's missing, what's broken, and which service should be next?

Marketplace: https://marketplace.visualstudio.com/items?itemName=bitno.services-by-bitno


r/redis • • 3d ago

News Workshop today: Getting AI agents to work in production with Redis Iris

0 Upvotes

Hey everyone! Redis is hosting a workshop today on getting AI agents to work reliably in production and at scale.

We’ll walk through new Redis Iris capabilities covering context retrieval, intent routing, agent memory, and messaging, including how to:

  • Control what agents remember and forget

  • Give agents relevant context with less custom integration work

  • Trace failures and recover from dropped connections

Simba Khadder, Redis’s Head of AI Engineering, and Karin Landers will lead the session.

Webinar details and registration


r/redis • • 5d ago

News With Redis ADBC, support for Apache Airflow, Dagster, Prefect, Mage, Kestra

2 Upvotes

Redis is becoming easier to use in the data workflows teams already run.

With Redis ADBC, the orchestration ecosystem now includes integration paths for five tools:
• Apache Airflow
• Dagster
• Prefect
• Mage
• Kestra

Airflow and Prefect already had native Redis integrations. ADBC adds supported SQL,
schema discovery, typed Apache Arrow results, and bulk ingestion—and expands access to Dagster, Mage, and Kestra.

For data engineers, that opens up a practical workflow: query Redis from a pipeline task, process Arrow data, and write results back as part of an orchestrated job.

Explore the integration guide at https://github.com/redis/redis-adbc-driver/blob/main/docs/data-engineering-adbc-support.md

#Redis #DataEngineering #ApacheArrow #DataOrchestration #ADBC


r/redis • • 10d ago

News BI and Visualization with data within Redis

2 Upvotes

Your Redis data should be easier to explore, visualize, and turn into useful applications.

We’re expanding those workflows with Redis ADBC and Apache Arrow Flight SQL, connecting SQL tables backed by Redis and data stored in Redis HASHes to familiar BI and visualization tools:

  • Streamlit: build interactive data apps using SQL query results.

  • Plotly and Matplotlib: turn Redis-backed data into interactive visualizations and publication-ready charts.

  • Apache Superset: explore datasets and run SQL through the Redis SQLAlchemy integration.

  • Tableau: connect through Flight SQL JDBC for table discovery and data previews.

  • Metabase: use a community Flight SQL plugin for queries, metadata discovery, and supported write Actions.

The value is practical: use familiar SQL and Python workflows, move query results through Apache Arrow, and bring operational data into analysis with the tools your team already knows.

Want to try it? Start with the setup instructions, examples, and tool-specific guidance:

📖 BI and visualization integration guides
📖 Superset connection guide

#Redis #ApacheArrow #ADBC #BusinessIntelligence #DataVisualization


r/redis • • 11d ago

Tutorial Tutorial: Testing a changed Streams consumer without stealing entries from the stable one

0 Upvotes

Sharing a tutorial that might be helpful for anyone testing Redis Streams.

The problem: start a changed consumer in the same consumer group as the stable one, and XREADGROUP hands it a share of everyone's entries. It processes and acknowledges them, and the stable consumer never sees them.

What the example does instead. (The routing rules come from Signadot, but these patterns work on any Redis with Streams):

  • Each test environment reads through its own consumer group, created at $, so every group sees every new entry.

  • Entries have no headers, so the producer writes a routing key into each entry as extra fields (traceparent and baggage).

  • Every consumer checks each entry, processes only the ones meant for it, and XACKs all of them, so nothing stays pending.

  • Each consumer reads its own pending entries at startup and runs XAUTOCLAIM once a minute for entries a replaced pod left behind.

Tradeoffs: every group reads the whole stream, so read load grows with the number of test consumers, and groups outlive their environments until you XGROUP DESTROY them.

Write-up: https://www.signadot.com/docs/tutorials/testing-redis-streams

Source: https://github.com/signadot/examples/tree/main/selective-consumption-with-redis-streams/python

Full transparency, I work for Signadot.


r/redis • • 12d ago

News Redis adapters for dbt,

2 Upvotes

What if you could use dbt to build, test, and document data models directly in Redis?

I’m excited to share Redis adapters for dbt, built on the Redis ADBC driver.

The project brings familiar dbt workflows to Redis:

• SQL models with tables, views, and incremental builds

• Snapshots, model contracts, and data tests

• Python models using Apache Arrow

• Documentation with model descriptions stored in Redis

There’s also an end-to-end NYC taxi example: load trip data into Redis, transform it into analytical models, and validate the results with standard dbt commands.

The project supports dbt Core 1.x and includes experimental native Redis support for dbt v2 through a custom Rust engine fork. The v2 integration has been validated on macOS and Linux; it currently requires building that Redis-enabled engine.

My goal is to make Redis accessible through workflows data teams already know—and explore what becomes possible when dbt transformations produce data applications can use directly in Redis.

Explore the code, try the example, and share your feedback:

github.com/redis/redis-dbt-adapter

#Redis #dbt #DataEngineering #OpenSource #ApacheArrow


r/redis • • 14d ago

Discussion Valkey.app - native macOS app for running local Valkey servers

2 Upvotes

I'm the author. Valkey.app: https://valkey.app, source: https://github.com/alhassanaraouf/Valkey.app

Native macOS app for local Valkey development. Runs multiple servers side by side, each with its own port, Valkey version (7.2 to 9.1), data directory, and live log. Menu bar controls for start/stop and opening valkey-cli. Supports JSON and Bloom modules per server.

Free and Apache-2.0. Not notarized yet, first launch requires a one-time allow in Privacy & Security, steps are on the site.

Feedback on version coverage or local workflow issues welcome.


r/redis • • 17d ago

Discussion [Security incident] Redis port exposure — what happened and how we plugged the hole

0 Upvotes

An error appeared in our bug tracker:

RedisClient::CannotConnectError: getaddrinfo: Temporary failure in name resolution (redis://redis:6379)

At first glance, it looked like a standard connection issue. However, the underlying cause turned out to be more interesting.

What happened:

The Redis port (6379) was exposed publicly. An automated bot discovered it and executed the `SLAVEOF` / `REPLICAOF` command attempting to turn our Redis instance into a replica of the attacker's server. This is a known attack that exploits the fact that Redis does not require authentication by default.

The full attack chain (had it succeeded):

  1. The bot connects to our Redis instance and executes `SLAVEOF attacker-host port`.

  2. Our Redis instance begins synchronization; the attacker sends their own RDB dump.

  3. The dump could contain the attacker's SSH keys, configured to be written to `/root/.ssh/authorized_keys` (using `CONFIG SET dir` and `CONFIG SET dbfilename`).

  4. The attacker gains SSH access to the host.

  5. From there, they could install a crypto-miner, a backdoor, or anything else.

Why it didn't work (and why it wouldn't have been catastrophic even if it had):

First, a replication error occurred the bot failed to establish a connection to its own server. The attack didn't progress past the first step.

Second, even if the dump had been successfully uploaded, our Redis instance is running inside a Docker container. The container's filesystem is isolated from the host, so simply dropping SSH keys into `/root/.ssh/` on the host itself via Redis wouldn't have worked.

The irony: Just a month earlier, a friend with whom I do some freelance work in Faster Than Light suggested performing a security audit on the host. It’s a good thing I did! I added a firewall, closed all open ports, and configured Nginx to filter out traffic from known bots. However, I overlooked the Redis port and that turned out to be the only open entry point.

Investigation and remediation:

  1. Checked the Redis status directly on the host—`INFO replication` confirmed that it had indeed switched to slave mode.

  2. Immediately switched it back to master mode manually: `REPLICAOF NO ONE`.

  3. Verified external access to the port ran `nc -zv <ip> 6379` from a laptop; the connection was successful, confirming the attack vector.

  4. Closed the port via the firewall and ran `nc -zv <ip> 6379` again—the connection no longer goes through; the port is closed.

Takeaway: If you use Redis, Memcached, MongoDB, or any other in-memory store, ensure they aren't listening on a public interface. It takes just two minutes but protects you against an entire class of attacks. I’ve prepared an article on this topic; it goes into more detail. If anyone is interested, I can send it over.


r/redis • • 19d ago

News I built redis-pane, a terminal UI for Redis and Valkey where keys update live

0 Upvotes

r/redis • • 22d ago

News Announcing redis-rs & redis-test 2 release candidates

Thumbnail
reddit.com
0 Upvotes

r/redis • • 26d ago

Discussion I’m building Redis-backed project memory for Claude and ChatGPT/Codex — looking for feedback on capture, retrieval, and agent handoffs

4 Upvotes

Hey folks — I’m working on Redis Agent Memory for Claude and ChatGPT, a project for persisting context across coding sessions and moving work between assistants.

The problem: decisions, debugging findings, and unfinished work tend to get buried in individual conversations. Starting a fresh chat or switching from Claude to Codex often means manually reconstructing that context.

This project connects supported clients to a shared Redis Agent Memory backend. The implementation has a few parts:

  • Session capture: Local Claude Code and Codex hooks save submitted prompts and available final responses into ordered sessions and searchable long-term memory.

  • Retrieval: Startup and per-prompt recall pull relevant context from the configured project scope, with character budgets and duplicate suppression.

  • Handoff checkpoints: Explicit checkpoints record goals, completed work, blockers, and next steps. Automatic checkpoints capture available evidence at Stop and PreCompact boundaries.

  • Project scoping: Git remote identity supplies the default namespace, so clones and worktrees can share project context. Cross-client recall requires matching owner, namespace, and store settings.

  • Delivery recovery: A durable local retry queue handles outages and tracks pending writes.

  • History imports: Existing Claude and ChatGPT exports can seed the memory store.

For example, Claude could investigate a failing test and save its findings, then Codex could retrieve that context and continue the investigation.

There are some practical boundaries: automatic capture depends on supported local hooks being installed and trusted. Ordinary Claude Desktop Chat uses model-selected memory tools, and ordinary ChatGPT Chat isn’t covered by the local Codex hooks. Saved context also doesn’t give another client access to your project files.

I’d appreciate technical input, especially on:

  1. Retrieval quality: How would you evaluate whether recalled context actually helps, versus injecting stale or irrelevant information?

  2. Memory lifecycle: How should superseded decisions, contradictory findings, and obsolete checkpoints be handled?

  3. Capture granularity: What deserves durable storage — conversation turns, tool outcomes, explicit decisions, or some combination?

  4. Agent handoffs: What information would you need to trust an assistant picking up another assistant’s work?

If you’ve built persistent memory or cross-agent workflows, I’d love to hear what failed in practice and what you’d change about this approach.


r/redis • • 26d ago

News Embed scheme into redis

Thumbnail
github.com
7 Upvotes

It let you write scheme code in redis


r/redis • • Oct 13 '26

Resource Redis streams: a different take on event-driven

Thumbnail
packagemain.tech
6 Upvotes

r/redis • • Oct 06 '26

Discussion Is Redis Commander Sentinel-aware?

4 Upvotes

What if application teams use Redis commander to manually insert/update data in Redis Sentinel Cluster.

I think in a well designed system, the application should be the thing writing to Redis and Redis commander exists mainly read only inspection tool.


r/redis • • Sep 30 '26

Help What do you verify before a planned Redis replica promotion?

7 Upvotes

A replica can report an active link and a small offset gap while still being a poor promotion target. The checks around persistence, replication backlog, module compatibility, ACLs, client discovery, and writable-disk behavior matter just as much as the final offset. A quiet primary also makes a one-time offset comparison look stronger than it is.

For a planned promotion, I am considering a gate that records the primary replication ID and offset, waits for the candidate to reach it, confirms there has been no full resync or replication error, and then briefly quiesces writes or uses a write fence before the final comparison. The candidate would also need a recent successful persistence cycle, enough disk and memory headroom, matching configuration and modules, and a tested client path to the new primary.

What does your actual promotion checklist include? Do you require WAIT acknowledgements, compare sampled keys or checksums, or run a synthetic write/read after promotion? How do you distinguish an expected offset change from evidence that clients are still writing to the old primary?


r/redis • • Sep 27 '26

Discussion How do you prove no Redis clients still use an old ACL credential before revoking it?

2 Upvotes

A credential rotation can look complete after the main application connects with the new Redis ACL user or password, while a scheduled job, failover process, dashboard, or rarely used environment still holds the old secret. Revoking it then turns that hidden dependency into an outage, and connection counts alone may not identify which credential created an existing connection.

What does your retirement gate include? I am considering creating a new ACL credential with the same command and key-pattern permissions, rolling it out by client group, shortening connection lifetimes, and watching ACL logs plus per-user connection and command activity through more than the longest job interval. The old credential would remain enabled only during a bounded observation window and would lose permissions before deletion.

Which Redis logs, ACL fields, or client metadata can reliably attribute activity to the old user? How do Sentinel, Cluster clients, connection pools, replicas, and long-lived pub/sub connections change the rollout, and is temporarily setting the old user to `off` a safe final test before removal?


r/redis • • Sep 26 '26

Resource GitHub - gkoos/caracal: Scoped distributed resilience for asynchronous operations

Thumbnail
github.com
5 Upvotes

r/redis • • Sep 16 '26

Discussion Built a fencing pattern to make Redis prove a cached value is committed before trusting it (no CDC required)

12 Upvotes

The problem: Any time you cache data from Postgres into Redis, the two writes can't be atomic. A crash or a rejected write between them leaves Redis holding a value that was never actually confirmed — and a normal cache-aside setup has no way to know that happened. TTLs just shrink the staleness window; they don't let the cache detect it's wrong.

The usual fix is CDC — Debezium, logical replication, an outbox table — where the app only ever writes to Postgres and a separate pipeline pushes changes into Redis asynchronously. That works well, but it's infrastructure you have to stand up and operate. I wanted to see if there was a self-contained way to get most of that safety without it.

What I ended up with: instead of one Redis value, store two fencing fields per key:

BEFORE = { uuid }              — raised the instant an update starts, holds no value
AFTER  = { uuid, value }       — written only once Postgres confirms the write

Trust rule:

BEFORE.uuid == AFTER.uuid  → cache is trusted, serve it
BEFORE.uuid != AFTER.uuid  → not trusted, read Postgres directly

Postgres stays the single source of truth the whole time. Redis is only ever allowed to answer once it can prove — via the matching UUID — that it reflects one specific, completed Postgres transaction. Every failure mode (a rejected write, a crash right after commit, a stale confirmation showing up late) just degrades into a cache miss, never a wrong answer.

I built a runnable demo around it — FastAPI + Postgres + Redis + Docker Compose — with a debug UI where you can trigger a rejected write, a crash-after-commit, and a delayed-confirmation race, and watch the fallback happen live instead of taking my word for it.

Things I'd genuinely like feedback on:

  • Where's the line where this stops being worth it and you should just run CDC instead?

  • I originally had a background worker doing repair as part of the correctness guarantee. I've since moved to repairing on-read (with a per-key singleflight lock so a hot dirty key doesn't cause a stampede of simultaneous Postgres reads) and demoted the worker to best-effort hygiene only. Curious if anyone's hit a case where on-read repair alone isn't sufficient.

  • Any concurrency hole in the UUID/version-gating I'm not seeing?

Repo (README has the full write-up + how to run it): https://github.com/kaleab-shumet/dual-write-problem-solution


r/redis • • Sep 15 '26

Resource All you need to know about redis

17 Upvotes

Over the weekend, I wrote a blog on Redis. Most of us see Redis as a caching layer beyond that, Redis can be used for many things, such as pagination, searching, etc. I have discussed all of these in the blog, along with why Redis is the fastest. If we understand Redis data structures and its atomic behavior, it will open up a lot of use cases.

Blog link: https://medium.com/@karthik.joshi103/all-you-need-to-know-about-redis-d8bfb52411dd

Share other use cases in the comments


r/redis • • Sep 14 '26

Discussion Benchmarked in-memory IP fraud scoring in FastAPI + Redis: got down to 0.04ms latency

8 Upvotes

Got tired of eating 300-400ms round trips to external fraud APIs just to check if an incoming IP is a datacenter, VPN, or Tor exit, so I tried an in-memory approach instead.

Spun up a bare-metal box in Vienna, loaded ~145k known bad ASNs and Tor exit nodes into a Redis cache, and put a small FastAPI triage service in front of it (plus a Go gateway for proxy tunnels).

Local lookup latency came down to roughly 0.04-0.1ms. Makes sense since it's now a memory read instead of a network round trip, but the actual gain depends a lot on your baseline API's latency.

Question for anyone running similar high-throughput security checks: do you keep threat vectors entirely in-memory with Redis, or do you lean on async background workers with a persistent DB fallback instead?


r/redis • • Sep 12 '26

Help Just learned Redis and looking for a genuinely interesting project to build with it

9 Upvotes

r/redis • • Sep 12 '26

Resource redis-lua-py: write Redis Lua scripts as real Python functions, not strings

Thumbnail
github.com
7 Upvotes