Redis Real Time Context Engine : Build a memory-aware AI agent with Redis Agent Memory and Redis Context Retriever

TL;DR: AI agents forget everything when a conversation ends, and can't query structured data without custom code. Redis solves both. Redis Context Retriever turns your entity data into auto-generated MCP tools any agent can discover and call. Redis Agent Memory gives agents persistent session memory and cross-session long-term memory backed by vector search. Together they make Redis a full context engine for AI applications.

Note: This tutorial uses the code from the following git repository:

https://github.com/redis-developer/redis-agent-memory-explorer

• Conversational memory: what was said, what was decided, what the client revealed across many sessions over time
• Structured knowledge: portfolio holdings, financial goals, pending action items — data that belongs in a queryable store, not a chat log

#How the two data layers compare

#Prerequisites

• A Redis Cloud account with Redis Agent Memory and Redis Context Retriever enabled
• An OpenAI API key
• Docker and Docker Compose
• Node.js 18+

#Setup

Note: Leave CTX_SURFACE_ID and MCP_AGENT_KEY blank — the app creates and writes them on first run.

#What you'll build

#Architecture

Note: The app runs as two processes: the API server (port 3001) and the LangGraph server (port 2024). In Docker, these are two separate containers from the same image. Both initialize their own Redis Agent Memory and Redis Context Retriever clients on startup.

#Tech stack

#Redis Context Retriever

#What is Redis Context Retriever?

#Why this matters

#Key concepts

• Retriever (Surface): A named collection tied to a data source (Redis) and an entity schema. Think of it as a queryable namespace. You can view and manage all your surfaces in the Redis Cloud Console.
• Entity schema: Defines your data model — field names, types, and descriptions. This drives tool generation.
• Admin key: Used to create and manage surfaces and issue agent keys. Generate one from the Context Retriever admin keys page in Redis Cloud and set it as CTX_ADMIN_KEY in your .env.
• Agent key: A scoped key the agent uses to call MCP tools, separate from the admin key used for retriever (surface) management.
• MCP tools: Auto-generated and self-describing. Tool names encode the query pattern — filter_<entity>_by_<field>, search_<entity>_by_text, get_<entity>_by_id, find_<entity>_by_<field>_range.

#What the entity schema looks like

Note: The redisIndices field controls which query tools are generated. A tag field produces a filter_<entity>_by_<field> tool. A numeric field produces a find_<entity>_by_<field>_range tool. A text field produces a search_<entity>_by_text tool. isKeyComponent: true produces a get_<entity>_by_id tool.

#What the actual records look like

#Creating a context retriever (context surface) and loading records

#Discovering and calling MCP tools

1. listTools() fetches the current tool list from the MCP server. The tool count and names depend entirely on the entity schema — adding an entity to the schema automatically adds new tools.
2. buildJsonSchemaToZod() converts each tool's JSON Schema parameters into a Zod schema so LangGraph can validate inputs and generate the tool signature for the LLM.
3. cs.callTool() sends a JSON-RPC request to the MCP server and returns the structured result, which extractMcpText() unwraps to a plain string for the agent.

#Context Retriever tools in the demo

Note: This is where Context Retriever has a meaningful accuracy advantage over a standard RAG approach. If the portfolio data were stored purely as embeddings and retrieved with a single vector search, the agent would get back a semantically close chunk of text — but it would have no guarantee of completeness or precision. It might miss holdings, return stale text, or conflate records from different clients.

With Context Retriever, the agent operates against structured records through typed MCP tools. It can call filter_holding_by_client_id to get every holding for a client, follow up with find_holding_by_current_value_range to narrow by value, and chain further tool calls as the question demands — each returning exact, queryable data rather than an approximation. The agent isn't doing a one-shot retrieval; it's navigating the data the same way a developer would query a database, just driven by the LLM's reasoning at runtime.

#Redis Agent Memory

#What is Redis Agent Memory?

• Session memory: The live conversation — an ordered log of events for the current session, scoped by sessionId. Each event has a role (user, assistant, system), content, and optional metadata. Session memory is ephemeral by design; it exists as long as the session is active.
• Long-term memory (LTM): Cross-session, persistent facts and events extracted from conversations. Backed by vector search so agents can retrieve semantically relevant memories regardless of which session produced them.

#Memory types

Note: In this demo, all auto-extracted long-term memories are episodic type because they come from meeting conversations. Redis Agent Memory extracts them automatically in the background — no code required beyond calling addSessionEvent. You can also create LTMs manually via createLongTermMemories() at any time. This is the right approach when you run your own extraction pipeline — processing documents, emails, call transcripts, or any content outside of a live session — and want to persist the resulting memories directly:

Automatic extraction and manual creation coexist — both end up in the same searchable LTM store.

#Session memory — storing a live conversation

#Long-term memory — what Redis remembers across sessions

#The memory prompt — injecting context into any LLM call

1. Determine total token budget — from contextWindowMax if provided, otherwise a lookup table by model name, otherwise a 128k default
2. Reserve tokens for the LTM results and formatting overhead
3. Spend the remaining budget on session events:
   • If all events fit → include verbatim as "Recent Conversation"
   • If events exceed the budget and an LLM is configured → summarize via LLM and include as "Session Summary"
   • If no LLM is configured → trim oldest events and keep the most recent ones

#The AI Copilot — real-time suggestions during playback

#The chatbot — querying across both data layers

#How the agent is wired

#RAM tools

#The dynamic system prompt

#Source attribution

#Sample questions and routing

#How it all works — the Redis data patterns

#Running the demo

1. Select a transcript from the dropdown in the left panel and click Play
2. Watch session memory fill in the Session memory tab (right panel) as each chunk is stored
3. Watch long-term memories appear in the Long-term memory tab after extraction runs in the background
4. Check the AI Copilot tab for context-aware suggestions generated every five chunks
5. Open the chatbot sidebar (top-right button) and ask questions across both data layers

#Next steps

• Add a new entity type. Edit data/wealth-advisor/dataset.config.json to add an entity to contextSurfaces.entities, add matching records to client-data.json, and restart. Redis Context Retriever generates new tools automatically — the agent picks them up with no code changes.
• Seed known facts as long-term memories. Use ram.createLongTermMemories() at setup time to pre-load facts about clients. Combine MemoryType.SEMANTIC facts with MemoryType.EPISODIC events for a richer memory base.
• Adjust the memory prompt budget. Change MEETING_MEMORY_CONTEXT_WINDOW_MAX in .env to control how many tokens are reserved for memory context in LLM calls.
• Explore with Redis Insight. Connect Redis Insight to your local Redis instance to browse session events, topic stores, and suggestion stores as JSON documents in real time.
• Build your own persona. The app is dataset-driven — all labels, roles, branding, suggestion types, and entity schemas come from dataset.config.json. Clone the wealth-advisor folder, edit the config, and swap in your own transcript data and entity records.

#References

• Redis Agent Memory documentation
• Redis Context Retriever documentation
• Source code: redis-agent-memory-explorer
• Redis Cloud — try free
• LangGraph documentation
• CopilotKit documentation
• Model Context Protocol (MCP)
• Redis Insight — GUI for exploring Redis data