r/redis

I work for Redis and I try to keep marketing posts here to a minimum, but this is a product announcement so I thought it appropriate.

Redis launched Redis Iris today. Redis Iris is a collection of tools that work together to store, manage, and serve context for AI agents. Those tools are:

• Redis Agent Memory—a rather handy tool to manage agent memory stored in Redis. Kinda does what it says on the tin.
• Redis Data Integration—a sort of ETL-like tool that syncs data between other data sources and Redis. Great for CDC.
• Redis LangCache—a semantic caching tool that lets you cache LLM responses much like you would database responses.
• Redis Search—an established search tool for searching data structures in Redis using both structured and semantic queries.
• Redis Context Retriever—brings all these tools together to provide context for your agents.

We have a blog post up on redis.io as well as a video out on YouTube if you want to go a little deeper.

Personally, I think the Redis Context Retriever sounds pretty cool. It lets you define schemas that match your problem domain—policies, accounts, users, products, whatever you care about—and exposes an MCP server that expresses that domain instead of the storage mechanism. So, it returns policies instead of Hashes, products instead of JSON.

I haven't had a chance to use all of these yet myself. I've used Redis Agent Memory and Redis Search and poked around with Redis LangCache a bit. I'm looking forward to messing with Redis Context Retriever.

Hey r/redis,

I’m experimenting with a Go project called Moxy. The goal is to add reliability semantics on top of Redis queues without turning Redis into a full broker.

The problem I’m trying to solve is the classic:

LPOP queue

If a worker crashes after receiving the task, the task is gone.

Right now the model looks like:

READY -> PROCESSING -> COMPLETED
READY -> PROCESSING -> EXPIRED -> REQUEUED -> READY

Current Redis approach:

• ready list + processing list
• LMOVE ready processing RIGHT LEFT
• Lua scripts for Complete/Requeue
• Go lease engine tracking expirations and ACKs

Still early:

• no TCP/RESP layer yet
• no WAL/snapshots/crash recovery yet
• still single-node

Main thing I’m looking for feedback on:

• Does the READY/PROCESSING list model still make sense today?
• Is LMOVE + Lua a sane direction before moving to something more advanced?
• Would you use Redis Streams for this instead?
• What Redis-specific failure cases should I think about before building the network layer?

Mostly looking for architecture feedback from people who’ve used Redis heavily in production.