Build 2026: New Azure Managed Redis Capabilities for AI-Ready Applications
As AI-driven applications continue to evolve, developers need a data platform that can keep up, delivering real time performance, intelligent context, and enterprise grade security at scale. At Microsoft Build 2026, we’re excited to share the latest capabilities in Azure Managed Redis, designed to help you build faster, smarter, and more secure applications, especially in the era of AI agents and intelligent services. These releases bring together a set of foundational improvements across security, performance, developer experience, and AI integration, reflecting our ongoing investment in making Azure Managed Redis one of the top data platforms for modern, real-time workloads. Powering the next generation of AI applications Azure Managed Redis is increasingly being used as the memory and context layer for AI powered applications, including copilots, chatbots, and autonomous agents. At Build 2026, we are highlighting enhanced capabilities to support these scenarios: Vector search and semantic caching to improve response relevance while reducing latency and cost Real-time memory and context management for agent workflows Support for retrieval augmented generation, also known as RAG, and event driven architectures These capabilities enable developers to build applications that retrieve the right information in milliseconds, delivering more responsive and context aware AI experiences. New enterprise grade data access with Entra ID based RBAC Security and governance are critical as Redis becomes a shared platform across teams and applications. At Build, we are introducing Entra ID based role-based access control for data access, now available in public preview. With this capability, you can: Enforce fine grained access control over Redis data with ACL Align permissions with your enterprise identity system Replace shared keys with identity-based access Improve auditability and compliance This feature is built on Redis access-control lists and enables secure, multi team collaboration without increasing operational complexity. Learn more. Flash-Optimized SKUs Now Generally Available (Up to 1.5 TB) We’re excited to announce the general availability of Flash-Optimized Azure Managed Redis (AMR) SKUs, now supporting capacities up to 1.5 TB. These new SKUs deliver a compelling balance of performance and cost-efficiency, enabling customers to run large-scale workloads with predictable latency and significantly lower memory costs. Learn more. Enterprise readiness In addition to new innovations, this release includes several important enhancements that improve enterprise readiness and feature completeness, based on customer feedback and real-world usage. Key updates include: Access control lists for controlling user permissions at a granular level Keyspace notifications (in preview) to enable event driven application patterns Larger SKUs, including 250 gigabyte and 350 gigabyte tiers, to support more demanding workloads Dashboards with Grafana in Azure Managed Redis bring Azure Monitor's built-in Grafana experience directly into the Azure portal. Expanded migration tooling for both Azure Cache for Redis and Redis Enterprise These updates address critical customer needs and remove barriers to adoption, especially for large scale and regulated environments. Simplified, AI-assisted migration With the retirement of Azure Cache for Redis underway, migration is a top priority for many customers. To support this transition, we are introducing: AI assisted migration planning to help assess and map existing environments A native migration workflow in the Azure portal for guided execution Tooling for both Azure Cache for Redis and Redis Enterprise migrations Together, these capabilities provide a more seamless and structured migration path, reducing risk while accelerating time to value. Built for performance, scale, and reliability Azure Managed Redis continues to deliver enterprise grade improvements, including: High throughput, low latency in memory processing Zone redundancy and geo replication for resilience Ongoing investments in developer experience and operational tooling These capabilities ensure you can scale confidently, whether you are supporting high traffic applications or real time AI systems. Developer takeaways At Build 2026, we are helping developers move from experimentation to production with technologies that are secure, scalable, and AI ready by design. These updates position Azure Managed Redis as a core building block for modern applications, including: AI agents and copilots Real-time personalization and recommendations Cloud native microservices High performance transactional systems Learn more at Build If you’re attending Build 2026 (in-person or online) you can find you Azure Managed Redis across sessions, demos, and the in-person expo experience. Lightning talk Stop by our lightning talk for fast, focused 15-minute sessions designed to give you an early look at what’s new. These in-person discussions spotlight emerging capabilities and real-world scenarios, offering a quick way to understand where the platform is evolving next. LTG41 | Faster and smarter agents with Redis and Foundry 📅 Wednesday, June 3 🕛 4:20 PM - 4:35 PM PDT On-demand session If you prefer to explore at your own pace, our on-demand sessions provide deeper walkthroughs of key updates and product capabilities. You’ll find detailed demos, scenario-based guidance, and technical insights that help you translate new features into real-world value. OD823 | Faster AI Responses with Semantic Caching in Azure Managed Redis Booth & expo presence Visit us at the Azure Data / NoSQL booth in the main expo hall to connect directly with product experts, see live demos, and explore real customer scenarios in action. Build’s interactive spaces are designed for hands-on engagement, giving you the opportunity to ask questions, test capabilities, and get guidance tailored to your environment. These experiences provide practical guidance, demos, and architectural patterns to help you apply these new Azure Managed Redis capabilities in your own applications. See you there!Know before you go: Azure Managed Redis at Microsoft Build 2026
Microsoft Build 2026 is almost here, and this year’s event boasts a new format, as well as a deeper technical focus across key themes such as AI agents, cloud-native applications, data platforms, developer tooling, and intelligent infrastructure. The updates showcased at Build signal where Microsoft is investing next—and how customers can start preparing now. Whether you’re joining in person or online, this is your opportunity to see how Azure is shaping the next generation of AI-powered applications—and where Azure Managed Redis fits into that future. In this post, we’ll cover everything you need to know to prepare, including what Build is (and how to participate), as well as where you can find Azure Managed Redis across sessions, demos, and the in-person expo experience. Where to find Azure Managed Redis at Build Azure Managed Redis’s presence at Build 2026 spans a mix of on-demand digital and in-person experiences, ranging from technical deep dives to open ended developer conversations. No matter your stage of development, Microsoft has you covered. Lightning talk Stop by our lightning talk for fast, focused 15-minute sessions designed to give you an early look at what’s new. These in-person discussions spotlight emerging capabilities and real-world scenarios, offering a quick way to understand where the platform is evolving next. LTG41 | Faster and smarter agents with Redis and Foundry 📅 Wednesday, June 3 🕛 4:20 PM – 4:35 PM PDT The Azure Managed Redis Lightning Talk will focus on: How Azure Managed Redis and Microsoft Foundry help developers build more effective AI agents High-performance in-memory data patterns for powering agent memory and context Vector search and semantic caching to reduce latency, lower cost, and return more relevant responses Practical approaches for RAG, persistent memory, and event-driven agent workflows This session is ideal for anyone looking to understand how Redis can serve as the data and memory layer for production-ready AI agents—helping deliver the right context in milliseconds and enabling richer, real-time reasoning. Expect to see a preview of upcoming investments across performance, developer experience, and AI-powered workflows. These sessions are ideal if you want a concise view of what’s changing and what it enables—before diving deeper into the full roadmap. ➡️ Tip: Lightning talks are in-person only and not available on demand—plan to attend live. On-demand session If you prefer to explore at your own pace, our on-demand sessions provide deeper walkthroughs of key updates and product capabilities. You’ll find detailed demos, scenario-based guidance, and technical insights that help you translate new features into real-world value. OD823 | Faster AI Responses with Semantic Caching in Azure Managed Redis on-demand session will cover: Building AI agents with Azure Managed Redis and Microsoft Foundry Real-time memory and context for agent workflows Vector search, semantic caching, and agent memory This session is ideal for: Developers building copilots or autonomous agents Architects designing large scale LLM chatbots Teams modernizing applications for AI ➡️ Tip: Sessions are designed to help you move from awareness to action, with a clearer understanding of how to apply what’s coming next. On-demand session will be available on Build Day 1, so keep an eye out for our Azure Managed Redis Build 2026 announcements blog for the on-demand session link and access details. Booth and expo presence Visit us on-site to connect directly with product experts, see live demos, and explore real customer scenarios in action. Build’s interactive spaces are designed for hands-on engagement, giving you the opportunity to ask questions, test capabilities, and get guidance tailored to your environment. Azure Managed Redis will be represented within a shared Azure Data / NoSQL booth experience, showcasing: Real-time AI application scenarios Vector search and semantic caching demos Integration with Azure AI Foundry and agent frameworks At the booth, you’ll get an early look at upcoming enhancements and how they fit into the broader Azure ecosystem. From performance improvements to new integrations and AI-driven experiences, you’ll leave with a clearer picture of how the product is evolving—and how to take advantage of it. ➡️ Tip: Expect a cross-product narrative aligned with Azure Data + AI platform positioning. What to expect at Build 2026 Microsoft Build 2026 is the company’s flagship developer conference, bringing together engineers, architects, and technical leaders for two days of hands-on sessions, product announcements, and deep technical engagement. This year’s event is focused on real code, real systems, and practical AI development, with a strong emphasis on how developers can build, deploy, and scale intelligent applications using Azure and the broader Microsoft platform. Across keynotes, breakout sessions, demos, and labs, attendees will get early access to the next wave of platform capabilities—from advancements in AI agents and model deployment to updates across cloud infrastructure and developer tooling. How to prepare Register for Microsoft Build 2026 Browse the Session Catalog and start building your agenda Bookmark the Azure Managed Redis Lightning Talk (LTG41) Attend the Microsoft Build opening keynote to hear from CEO Satya Nadella and Microsoft leaders on how Microsoft is creating new opportunities for developers across its platforms in the era of AI Stay tuned for the On-Demand Session Catalog going live on Build Day 1, where you can explore Azure Data & AI sessions focused on AI agents, data platforms, and intelligent applications Visit the Expert Meetup area to connect with Microsoft engineers and product teams Follow along with Azure Managed Redis on Microsoft Tech Community, as well as Microsoft social channels (LinkedIn, X) for additional key announcements and real-time updates We look forward to meeting you there!Unlock real-time intelligence with Azure Managed Redis
Modern applications are no longer just transactional—they’re intelligent, conversational, and agent-driven. As organizations build copilots and autonomous agents, infrastructure requirements evolve. Applications must reason over context, retrieve knowledge instantly, and operate in real time. Azure Managed Redis is a fully-managed, enterprise-grade, in-memory data platform powered by Redis Enterprise and operated by Microsoft. It combines sub-millisecond performance, high availability, and advanced capabilities such as vector similarity search and multimodal data support. In this post, we’ll explore four key industry use cases for Azure Managed Redis—starting with building AI agents on modern agent frameworks. 1) Building AI agents on agent frameworks Agentic applications require fast memory, contextual retrieval, and low-latency orchestration. Azure Managed Redis provides the real-time data foundation for AI agents built on Microsoft Agent Framework, as well as LangChain and Azure AI services like Azure AI Foundry. Why Azure Managed Redis for AI agents? AI agents rely on: Vector similarity search for retrieval-augmented generation (RAG) Semantic caching to avoid repeated LLM calls Short-term memory for conversation state Long-term memory for preferences Real-time context updates from tools and APIs Azure Managed Redis enables all of these within a single in-memory data engine. Common Agent Scenarios Customer support agents retrieving knowledge base articles instantly Marketing copilots generating campaign insights using cached data Developer assistants accessing documentation with vector search Operational agents responding to real-time telemetry With vector indexing and JSON support, Redis can store embeddings alongside structured application data. Agents can retrieve relevant context in milliseconds, dramatically reducing latency and cost while improving response quality. For organizations adopting Microsoft’s AI ecosystem, Azure Managed Redis integrates seamlessly with Azure networking, identity, and compute services—making it a natural fit for production-grade agent architectures. 2) High-performance caching for modern applications Caching remains one of the most powerful patterns for improving performance and scalability. Applications backed by systems such as Azure SQL Database or Azure Database for PostgreSQL benefit from a high-speed caching layer to reduce repeated reads and minimize backend load. Azure Managed Redis enables: Microsecond data retrieval Reduced database pressure Improved application throughput Lower infrastructure costs Industry examples Retail & e-commerce: Cache product catalogs and pricing during peak events Financial services: Cache market data and pricing models Gaming: Store leaderboards and player states By inserting Redis between your application and your system of record, you gain immediate responsiveness without sacrificing durability. 3) Real-time analytics and streaming workloads For organizations that depend on real-time insight, in-memory processing is critical. Azure Managed Redis supports data structures such as Streams, Sorted Sets, JSON, and TimeSeries to enable near real-time analytics. Key Scenarios Fraud detection in financial services IoT telemetry ingestion and analysis Live dashboards for logistics and operations Dynamic pricing engines in retail Because processing happens in memory, latency remains predictable—even at scale. Streaming data can be ingested into Redis, enriched, scored, and surfaced to applications or dashboards immediately—without waiting for batch systems. 4) Session management at scale As applications scale horizontally, managing session state becomes increasingly complex. Azure Managed Redis provides a centralized, highly available session store that enables: Shared state across distributed app instances Automatic expiration with TTL Seamless failover and high availability Common Scenarios E-commerce platforms preserving shopping carts Media platforms tracking user preferences Enterprise SaaS applications managing authentication tokens By externalizing session state to Redis, applications become stateless and cloud-native—ready for autoscaling and global distribution. Enterprise-grade foundation for intelligent applications Azure Managed Redis delivers: 99.999% availability SLA Zone redundancy by default Automatic patching and updates Advanced security integration such as Entra ID authentication and private endpoints Native compatibility with modern Azure architectures Whether you're building AI agents, modernizing transactional applications, or enabling real-time analytics, Azure Managed Redis provides the in-memory data foundation required for intelligent, responsive systems. Getting started Ready to start building real-time and agent-driven applications with Azure Managed Redis? Explore the resources below to learn more, deploy your first instance, and experiment with AI-powered scenarios. Learn more: Azure Managed Redis Documentation Azure AI Foundry Overview Redis Enterprise Capabilities on Azure Try it yourself: Create an Azure Managed Redis instance Redis Quickstart (Azure) Build AI apps with Azure OpenAI + vector search Explore samples and architectures: Redis + LangChain RAG Sample Azure AI + Redis Vector Search Reference Architecture Redis Vector Similarity Search Examples Azure AI Foundry Samples Connect with the community: Azure Tech Community – Azure Databases Azure Managed Redis GitHub DiscussionsAzure Cache for Redis Retirement: What to Know and How to Prepare
Microsoft has announced the retirement of Azure Cache for Redis (Basic, Standard, Premium) and Azure Cache for Redis Enterprise/Enterprise Flash tiers. If you rely on these services today, it’s important to understand what’s changing, when, and how to prepare for a smooth transition to Azure Managed Redis. What’s Retiring and When? Azure Cache for Redis (Basic, Standard, Premium): Creation blocked for new customers: April 1, 2026 Creation blocked for existing customers: October 1, 2026 Retirement Date: September 30, 2028 Instances will be disabled starting October 1, 2028 Azure Cache for Redis Enterprise/Enterprise Flash: Creation blocked for all customers: April 1, 2026 Retirement Date: March 31, 2027 Instances will be migrated to Azure Managed Redis starting April 1, 2027 Existing instances will continue to run and receive regular maintenance until their respective retirement dates. More information here. Why Move to Azure Managed Redis? Azure Managed Redis is built on Redis Enterprise software, offering significant improvements: Enterprise-grade features: Active geo-replication, Redis modules, and more Performance & Cost: More performant and cost-effective than all tiers of Azure Cache for Redis Reliability: Zone redundancy by default, up to 99.999% availability with geo-replication Simplified Management: Native Azure experience, no Marketplace component, easier provisioning and billing compared to Azure Cache for Redis Enterprise Migration Guidance: What Customers Need to Do Upgrade Early Microsoft recommends upgrading to Azure Managed Redis as soon as possible, rather than waiting for the retirement deadline. Early migration ensures you benefit from new features and avoid last-minute disruptions. Migration Tooling For Basic/Standard/Premium: A command-line migration experience will be available in phases from February 2026, starting with the Basic caches support in preview. This tooling will allow you to migrate your cache endpoint, using the same hostname and access key for a seamless transition. For Enterprise/EnterpriseFlash: Migration tooling will roll out in phases starting March 2026. Downtime: If you use the migration tooling, expect only a brief connection blip (a few seconds) when the DNS record is updated. This is similar to the downtime experienced during regular maintenance. Application Changes Update your Redis hostname and access key to point to the new Azure Managed Redis instance. Azure Managed Redis is clustered by default. Most client libraries (e.g., StackExchange.Redis) work out-of-the-box, but check your library’s documentation for cluster support. Non-clustered support is available up to 25GB, but clustering is recommended for performance and scalability. For migrating data, see various options outlined in this blogpost: Data Migration with RIOT-X for Azure Managed Redis | Microsoft Community Hub and here. Reservations You can cancel or exchange your existing reservations for Azure Cache for Redis as described in Microsoft Cost Management documentation. Feature Parity and Regional Availability: What’s Coming and When Azure Managed Redis is actively being enhanced to close feature gaps and expand regional coverage. Here are the key ETAs for upcoming features and regions (all dates are tentative): Azure Public Regions France Central: November 2025 Qatar Central: December 2026 Azure Sovereign Clouds China Cloud: July 2026 US Gov Cloud: July 2026 Larger SKUs Memory Optimized, Balanced, Compute Optimized (up to 500GB): May 2026 Management Operations Scheduling maintenance windows: February 2026 Keyspace notifications: March 2026 If you need a feature or region that isn’t yet available, reach out to support or email AzureManagedRedis@microsoft.com for guidance. Resources for a Smooth Migration Migration Overview & Guidance Choosing the Right Tier Azure Managed Redis architecture Key Takeaways for Customers Don’t wait—start planning your migration to Azure Managed Redis now. Migration tooling will make the process easier, with phased rollouts starting November 2025. Feature parity is a priority, with major gaps closing by March–June 2026. Reach out to Microsoft support if you have blockers or need help with migration.Azure Managed Redis & Azure Cosmos DB with cache‑aside: a practical guide
Co-authored by James Codella - Principal Product Manager, Azure Cosmos DB, Microsoft; Andrew Liu - Principal Group Product Manager, Azure Cosmos DB, Microsoft; Philip Laussermair – Azure Managed Redis Solution Architect, Redis Inc. Using Azure Managed Redis alongside Azure Cosmos DB is a powerful way to reduce operational costs in read-heavy applications. While Azure Cosmos DB delivers low-latency point reads, an SLA-backed 10ms at the 99th percentile of requests, each read consumes Request Units (RUs), which directly impact your billing. For workloads with frequent access to the same data, caching those reads in Azure Managed Redis can dramatically reduce RU consumption and smooth out cost spikes. This cache-aside pattern allows applications to serve hot data from memory while preserving Azure Cosmos DB as the system of record. By shifting repeated reads to Azure Managed Redis, developers can optimize for cost efficiency without sacrificing consistency, durability, or global availability. What each service does: Azure Managed Redis is Microsoft’s first‑party, fully managed service built on Redis Enterprise. Azure Cosmos DB offers higher durable multi-region writes, high availability SLAs, and in-region single-digit millisecond latency for point operations. Co-locating app compute, Azure Managed Redis, and Azure Cosmos DB in the same region minimizes round-trips; adding Azure Managed Redis on top of Azure Cosmos DB reduces RU consumption from repeat reads and smooths tail latency spikes during peak load. Both Azure Managed Redis and Azure Cosmos DB offer great support for queries (including vector search) over JSON data to work well together fast efficient AI apps. This pairing doesn’t require a rewrite. You can adopt a cache‑aside strategy in your data‑access layer: look in Redis first; on a miss, read from Azure Cosmos DB and populate Redis with a TTL; on writes, update Azure Cosmos DB and invalidate or refresh the corresponding cache key. Use Azure Cosmos DB ETags in cache keys to make invalidation deterministic, and use the Azure Cosmos DB Change Feed to trigger precise cache refreshes when data changes. The Cache‑Aside (Lazy Loading) Pattern Read path: GET key from Azure Managed Redis. If found, return. If not, issue a point read to Azure Cosmos DB, then SET/JSON.SET the value in Azure Managed Redis with a TTL and return the payload to the caller. Write path: Persist to Azure Cosmos DB as the source of truth. Invalidate or refresh the related Redis key (for example, delete product:{id}:v{etag} or write the new version). If you subscribe to the Change Feed, an Azure Function can perform this invalidation asynchronously to keep caches hot under write bursts. Code Example (.NET): using System; using System.Collections.Generic; using System.Threading.Tasks; using Microsoft.Azure.Documents; using Microsoft.Extensions.Logging; using StackExchange.Redis; using Microsoft.Azure.StackExchangeRedis; using Azure.Identity; public static class CosmosDbChangeFeedFunction { private static RedisConnection _redisConnection; static CosmosDbChangeFeedFunction() { // Initialize Redis connection using Entra ID (Azure AD) authentication var redisHostName = Environment.GetEnvironmentVariable("RedisHostName"); // e.g., mycache.redis.cache.windows.net var credential = new DefaultAzureCredential(); var configurationOptions = ConfigurationOptions.Parse($"{redisHostName}:10000"); _redisConnection = RedisConnection.ConnectAsync(configurationOptions.ConfigureForAzureWithTokenCredentialAsync(credential)).GetAwaiter().GetResult(); } [FunctionName("CosmosDbChangeFeedFunction")] public static async Task Run( [CosmosDBTrigger( databaseName: "my-database", containerName: "my-container", ConnectionStringSetting = "CosmosDBConnection", LeaseContainerName = "leases")] IReadOnlyList<Document> input, ILogger log) { var cache = _redisConnection.GetDatabase(); if (input != null && input.Count > 0) { foreach (var doc in input) { string id = doc.GetPropertyValue<string>("id"); string etag = doc.GetPropertyValue<string>("_etag"); string cacheKey = $"item:{id}:v{etag}"; string json = doc.ToString(); await cache.StringSetAsync(cacheKey, json, TimeSpan.FromMinutes(10)); log.LogInformation($"🔄 Refreshed cache for key: {cacheKey}"); } } } } Why it works: The database handles correctness and global replication; the cache handles locality and frequency. You reduce repeated reads (and RU costs) and lower p99 by serving hot keys from memory close to the compute. TTLs give you explicit control over staleness; negative caching and stale‑while‑revalidate are easy extensions when appropriate. Design Choices That Matter TTLs: Choose TTLs that reflect business tolerance for staleness. Use jitter (±N%) to avoid thundering herds when many keys expire simultaneously. Keying and versioning: Include an ETag or version in the key, e.g., product:{id}:v{etag}. When the record changes, the ETag changes, naturally busting the old key. Cache stampede control: For hot keys that miss, use a short single‑flight lock so that one request refreshes the value while others wait briefly or serve stale data. Serialization: For portability, utilize compact JSON (RedisJSON if you want field‑level reads/writes). Keep values small to preserve cache efficiency. Failure semantics: Treat Azure Managed Redis as an optimization. If the cache is unavailable, the app should continue by reading from Azure Cosmos DB. Favor idempotent writes and retry‑safe operations. Why Azure Managed Redis & Azure Cosmos DB Work Well in Practice Local speed, global reach: Azure Cosmos DB targets a single-digit millisecond p99 for in-region point operations. Placing Azure Managed Redis in the same region enables sub-millisecond memory reads for repeated access patterns, providing optimal performance for high-frequency data access. The result is a shorter, more predictable critical path. Active‑active at both layers: Azure Cosmos DB supports multi‑region writes, so each region can accept traffic locally. Azure Managed Redis supports active geo‑replication across up to five instances, using conflict-free replicated data types (CRDT) to converge cache state. That yields region‑local cache hits with eventual consistency at the cache tier and strong guarantees at the database tier. Reference Architecture Regional deployment Ingress: Clients reach the app via Azure Front Door (or similar) and land on Azure App Service in a VNet. Read path: The app queries Azure Managed Redis first. On a miss, it performs a point read/write against Azure Cosmos DB (API for NoSQL) and updates Redis with a TTL. Write path: Writes go to Azure Cosmos DB. The Change Feed triggers an Azure Function that invalidates or refreshes related Redis keys. Observability: Use Azure Monitor for logs and metrics. Monitor cache hit ratio, gets/sets, evictions, and geo‑replication health on the Azure Managed Redis side; RU/s, throttles, and p99 latency on the Azure Cosmos DB side. Operations and SRE Considerations Co‑location: Keep compute, Azure Managed Redis, and the Azure Cosmos DB write/read region together to avoid unnecessary RTTs. Capacity planning: Size Azure Managed Redis memory for working‑set coverage and headroom for failover. Validate eviction policies (volatile‑TTL vs all‑keys) against workload behavior. Back‑pressure: Watch RU throttling on Azure Cosmos DB and evictions on Azure Managed Redis. High evictions or a low hit ratio indicate a working-set mismatch or TTLs that are too short. Testing: Load‑test with realistic key distributions and measure p50/p95/p99 on both cache hits and misses. Chaos‑test cache outages to verify graceful degradation. Security: Use managed identities for data plane access where supported; apply App Service access restrictions and VNet integration as appropriate; audit with Azure Monitor logs. Putting It All Together Adopt cache‑aside in one region, measure hit ratio and RU savings, then add Change Feed–based invalidation to keep hot keys fresh under write load. When you need global scale, enable Azure Cosmos DB multi-region writes and Azure Managed Redis active geo-replication so that every region serves users locally. You end up with fast read paths, clear consistency boundaries, and a deployment model that scales without surprises. Next steps Review Azure Managed Redis documentation - https://learn.microsoft.com/azure/redis/ , Learn more about Cache Aside pattern in the Azure Architecture Center - https://learn.microsoft.com/azure/architecture/patterns/cache-aside Start with a sample app - https://github.com/AzureManagedRedis/What’s new in Azure Managed Redis: Ignite 2025 feature announcements
Azure Managed Redis continues to power the world’s most demanding, low-latency workloads—from caching and session management to powering the next generation of AI agents. At Microsoft Ignite 2025, we’re excited to announce several new capabilities designed to make Azure Managed Redis even more scalable, manageable, and AI-ready. Bigger, faster, stronger: new enterprise-scale SKUs (generally available) We are expanding our capacity portfolio with the general availability of Memory Optimized 150 and 250, Balanced 150 and 250, Compute Optimized 150 and 250 SKUs/, bringing higher throughput, lower latency, and greater memory capacity for your most demanding workloads. Whether you’re running global gaming platforms, AI-powered personalization engines, or enterprise-scale caching tiers, these new SKUs offer the performance headroom to scale with confidence. Redis as a knowledge base for AI Agents Azure Managed Redis is now available as part of the Azure AI Foundry MCP tools catalog, allowing customers to use Redis as a knowledge store or memory store for AI agents. This integration makes it simple to connect Redis to Foundry-based agents, enabling semantic searching, long term and short term memory, and faster reasoning for multi-agent applications—all running on trusted Azure infrastructure. Scheduled Maintenance (public preview) You can now configure maintenance windows for their Azure Managed Redis instances, giving you greater control and predictability for planned service updates. This capability helps align maintenance with your own operational schedules—minimizing disruption and providing flexibility for mission-critical applications. Terraform Provider for Azure Managed Redis We’re making infrastructure automation even easier with a dedicated Terraform provider for Azure Managed Redis. This new provider enables you to declaratively create, manage, and configure AMR resources through code, improving consistency and streamlining CI/CD pipelines across environments. Reserved Instances: now in 30+ Regions Azure Managed Redis now supports Reserved Instances in over 30 regions, with more coming soon. Reserved pricing provides predictable costs and savings for long-term workloads.. Go to Azure Portal | Reservations | Add and search for ‘Azure Cache for Redis’. Azure Managed Redis SKUs like Balanced, Computer Optimized, Memory Optimized, and Flash Optimized, would show up as sub SKUs in the category. Reserved Instance is available for 35% discount with 1 year purchase and 55% discount with 3 year purchase. Learn More & Get Started Azure Managed Redis is redefining what’s possible for caching, data persistence, and agentic AI workloads. Explore the latest demos, architecture examples, and tutorials from Ignite: Learn more about Azure Managed Redis Try Azure Managed Redis samples on GitHub Watch the Azure Managed Redis session at Ignite on-demand (BRK129) Explore Redis as a memory store for Microsoft Agent Framework Introducing the PublicNetworkAccess property to Azure Managed Redis | Microsoft Community Hub Ready to build Internet-scale AI apps with Azure Managed Redis? Start today at aka.ms/hol-amr.Azure Managed Redis at Ignite 2025: pre-day, session, and booth
Microsoft Ignite 2025 is almost here! Many practitioners are surprised by the powerful new capabilities in Azure Managed Redis—and now is your chance to see them in action. Whether you are modernizing applications, accelerating AI workloads, or building next-generation agent architectures, Azure Managed Redis is your key to speed and scale. Don’t miss the chance to connect with experts from Microsoft and Redis at our pre-day workshop and general session at Ignite and learn how to: Unlock high-performance caching for demanding workloads Build a powerful memory layer for agentic applications Leverage vector storage for Retrieval-Augmented Generation (RAG) Optimize LLM costs with semantic caching All in one fully-managed service—Azure Managed Redis. Connect with Azure Managed Redis team at Ignite 2025 1. Ignite pre-day workshop: Build Internet-Scale AI Apps with Azure Managed Redis — Caching to Agents (in-person only) When: Ignite pre-day on Monday, November 17, 2025, 1pm-5pm PT Where: Moscone Center, San Francisco Registration: Add this optional in-person workshop in the Ignite registration → Building AI applications and agents at internet scale requires more than speed — it demands unified memory, context, and scalability. You’ll see live demos and learn how to build and scale intelligent applications using Azure Managed Redis for caching and modern AI workloads, architect your applications for performance, reliability, and scale with geo-replication, and migrate to Azure Managed Redis. Seats are limited, please sign up today. 2. Breakout Session: Smarter AI Agents with Azure Managed Redis - BRK129 (in-person and online) View session details on the Ignite website and save to your event favorites Azure Managed Redis with Azure AI Foundry and Microsoft Agent Framework let developers build adaptive, context-aware AI systems. Redis handles real-time collaboration, persistent learning, and semantic routing, while the Agent Framework supports advanced reasoning and planning. Integrated short- and long-term memory lets agents access relevant data directly, simplifying development and operations. Azure Managed Redis supports MCP for control and data plane tasks, enabling easy management and scaling of workloads and knowledge stores. Join us to discover how to build scalable, multi-agent systems backed by the performance, reliability, and unified memory of Redis on Azure. 3. Visit the Azure Managed Redis booth in the Expo Hall Have questions? Looking to talk architecture, migration, and supercharging your AI apps? Visit us in the Expert Meetup Zone to connect with the Microsoft and Redis product teams, engineers, and architects behind Azure Managed Redis. Prepare for Ignite Learn more about Microsoft Ignite Explore the Azure Managed Redis documentation. Try the hands-on workshop for Azure Managed Redis.Redis named Stack Overflow’s top data storage tool for AI Agents
Redis recognized by developers on Stack Overflow as the #1 data storage tool for AI agent workloads and #5 database in 2025. Microsoft is the only cloud provider to offer Redis Enterprise as a fully native, managed service with Azure Managed Redis.Orchestrate multi-LLM workflows with Azure Managed Redis
Authors: Roberto Perez, George von Bülow & Roy de Milde Key challenge for building effective LLMs In the age of generative AI, large language models (LLMs) are reshaping how we build applications — from chatbots to intelligent agents and beyond. But as these systems become more dynamic and multi-modal, one key challenge stands out: how do we route requests efficiently to the right model, prompt, or action at the right time? Traditional architectures struggle with the speed and precision required to orchestrate LLM calls in real-time, especially at scale. This is where Azure Managed Redis steps in — acting as a fast, in-memory data layer to power smart, context-aware routing for LLMs. In this blog, we explore how Redis and Azure are enabling developers to build AI systems that respond faster, think smarter, and scale effortlessly. Across industries, customers are hitting real limitations. AI workloads often need to track context across multiple interactions, store intermediate decisions, and switch between different prompts or models based on user intent — all while staying responsive. But stitching this logic together using traditional databases or microservice queues introduces latency, complexity, and cost. Teams face challenges like keeping routing logic fast and adaptive, storing transient LLM state without bloating backend services, and coordinating agent-like behaviors across multiple components. These are exactly the pain points AMR was built to address — giving developers a low-latency, highly available foundation for real-time AI orchestration and more. How to use Azure Managed Redis as a Semantic Router Semantic routing uses AI to route user queries to the right service, model or endpoint, based on their intent and context. Unlike rule-based systems, it leverages Generative AI to understand the meaning behind requests, enabling more accurate and efficient decisions. Importantly, the semantic router itself does not forward the query—it only selects the appropriate route. Your application is responsible for taking that routing decision and sending the query to the correct agent, model, or human. The users sends a query, which is passed to the system for processing The query is analyzed by an embedding model to understand its semantic intent and context The semantic router evaluates the user’s intent and context to choose the optimal route: A specific model for further processing An agent to handle the query A default response if applicable Escalation to a human for manual handling, if needed Valid queries go through the RAG pipeline to generate a response The final response is sent back to the user Code examples + Architecture Example: Jupyter Notebook with Semantic Router Let’s look at a Jupyter Notebook example that implements a simple Semantic Router with Azure Managed Redis and the Redis Vector Library. First, we install the required Python packages and define a connection to an AMR instance: pip install -q "redisvl>=0.6.0" sentence-transformers dotenv Define the Azure Managed Redis Connection. import os import warnings warnings.filterwarnings("ignore") from dotenv import load_dotenv load_dotenv() REDIS_HOST = os.getenv("REDIS_HOST") # ex: "gvb-sm.uksouth.redis.azure.net" REDIS_PORT = os.getenv("REDIS_PORT") # for AMR this is always 10000 REDIS_PASSWORD = os.getenv("REDIS_PASSWORD") # ex: "giMzOzIP4YmjNBGCfmqpgA7e749d6GyIHAzCaF5XXXXX" # If SSL is enabled on the endpoint, use rediss:// as the URL prefix REDIS_URL = f"redis://:{REDIS_PASSWORD}@{REDIS_HOST}:{REDIS_PORT}" Next, we create our first Semantic Router with an allow/block list: from redisvl.extensions.router import Route, SemanticRouter from redisvl.utils.vectorize import HFTextVectorizer vectorizer = HFTextVectorizer() # Semantic router blocked_references = [ "things about aliens", "corporate questions about agile", "anything about the S&P 500", ] blocked_route = Route(name="block_list", references=blocked_references) block_router = SemanticRouter( name="bouncer", vectorizer=vectorizer, routes=[blocked_route], redis_url=REDIS_URL, overwrite=False, ) To prevent users from asking certain categories of questions, we can define example references in a list of blocked routes using the Redis Vector Library function SemanticRouter(). While it is also possible to implement blocking at the LLM level through prompt engineering (e.g., instructing the model to refuse answering certain queries), this approach still requires an LLM call, adding unnecessary cost and latency. By handling blocking earlier with semantic routing in Azure Managed Redis, unwanted queries can be intercepted before ever reaching the model, saving LLM tokens, reducing expenses, and improving overall efficiency. Let’s try it out: user_query = "Why is agile so important?" route_match = block_router(user_query) route_match The router first vectorizes the user query using the specified Hugging Face text vectorizer. It finds a semantic similarity with route reference “corporate question sabout agile” and returns the matching route ‘block_list`. Note the returned distance value – this indicates the degree of semantic similarity between the user query and the blocked reference. You can fine-tune the Semantic Router by specifying a minimum threshold value that must be reached to count as a match. For full details and more complex examples, you can explore the Jupyter Notebooks in this GitHub repository. How do customers benefit? For customers, this technology delivers clear and immediate value. By using Azure Managed Redis as the high-performance backbone for semantic routing and agent coordination, organizations can significantly reduce latency, simplify infrastructure, and accelerate time-to-value for AI-driven experiences. Instead of building custom logic spread across multiple services, teams get a centralized, scalable, and fully managed in-memory layer that handles vector search, routing logic, and real-time state management — all with enterprise-grade SLAs, security, and Azure-native integration. The result? Smarter and faster LLM interactions, reduced operational complexity, and the flexibility to scale AI use cases from prototypes to production without re-architecting. Whether you're building an intelligent chatbot, orchestrating multi-agent workflows, or powering internal copilots, this Redis-backed technology gives you the agility to adapt in real time. You can dynamically route based on user intent, past interactions, or even business rules — all while maintaining low-latency responses that users expect from modern AI applications. And because it’s fully managed on Azure, teams can focus on innovation rather than infrastructure, with built-in support for high availability, monitoring, and enterprise governance. It’s a future-proof foundation for AI systems that need to be not just powerful, but precise. Try Azure Managed Redis today If you want to explore how to route large language models efficiently, Azure Managed Redis provides a reliable and low-latency solution. You can learn more about the service on the Azure Managed Redis page and find detailed documentation in the Azure Redis overview. For hands-on experience, check out the routing optimization notebook and other examples in the Redis AI resources repository and GitHub - loriotpiroloriol/amr-semantic-router. Give it a try to see how it fits your LLM routing needs.Building faster AI agents with Azure Managed Redis and .NET Aspire
AI is evolving fast—and so are the tools to build intelligent, responsive applications. In our recent Microsoft Reactor session, Catherine Wang (Principal Product Manager at Microsoft) and Roberto Perez (Microsoft MVP and Senior Global Solutions Architect at Redis) shared how Azure Managed Redis helps you create Retrieval-Augmented Generation (RAG) AI agents with exceptional speed and consistency. Why RAG agents? RAG applications combine the power of large language models (LLMs) with your own data to answer questions accurately. For example, a customer support chatbot can deliver precise, pre-approved answers instead of inventing them on the fly. This ensures consistency, reduces risk, and improves customer experience. Where Azure Managed Redis fits with agentic scenarios In this project, Azure Managed Redis is used as a high-performance, in-memory vector database to support Agentic Retrieval-Augmented Generation (RAG), enabling fast similarity searches over embeddings to retrieve and ground the LLM with the most relevant known answers. Beyond this, Azure Managed Redis is a versatile platform that supports a range of AI-native use cases, including: Semantic Cache – Cache and reuse previous LLM responses based on semantic similarity to reduce latency and improve reliability. LLM Memory – Persist recent interactions and context to maintain coherent, multi-turn conversations. Agentic Memory – Store long-term agent knowledge, actions, and plans to enable more intelligent and autonomous behavior over time. Feature Store – Serve real-time features to machine learning models during inference for personalization and decision-making. These capabilities make Azure Managed Redis a foundational building block for building fast, stateful, and intelligent AI applications. Demo highlights In the session, the team demonstrates how to: Deploy a RAG AI agent using .NET Aspire and Azure Container Apps. Secure your Redis instance with Azure Entra ID, removing the need for connection strings. Use Semantic Kernel to orchestrate agents and retrieve knowledge base content via vector search. Monitor and debug microservices with built-in observability tools. Finally, we walk through code examples in C# and Python, demonstrating how you can integrate Redis search, vector similarity, and prompt orchestration into your own apps. Get Started Ready to explore? ✅ Watch the full session replay: Building a RAG AI Agent Using Azure Redis ✅ Try the sample code: Azure Managed Redis RAG AI Sample
