AI tech talk series: Agent context layer

Session highlights:

• Session 1
  Start with retrieval that holds up at scale

  Most agent demos run on a small, tidy dataset. Production doesn't. Retrieval that returns clean answers against a few thousand records can fall apart once it's up against a few million vectors, and by the time a team notices, the agent has already shipped.

  This session sets up the base app you'll build on for the rest of the series and gets retrieval working with Redis Search, so it's fast at demo scale and still fast once the data grows. We'll cover how Redis Search handles hybrid retrieval (vector plus filters) in the same round trip, and why sub millisecond lookups matter once an agent is making several retrieval calls per turn, not just one.

  Samuel Agbede
• Session 2
  Compounding memory

  An agent that forgets the customer between sessions isn't reasoning, it's guessing with extra steps. Most teams patch this by stuffing more history into the context window, which works until it doesn't: costs climb, latency climbs, and the agent still loses the thread the moment a session restarts.

  This session adds Agent Memory on top of the app from session one, so context carries across turns, across sessions, and across restarts, without relying on the context window to hold everything. We'll show how memory is written, retrieved, and pruned, and how that's different from just caching the last conversation.

  Samuel Agbede
• Session 3
  Context retrieving at scale

  Calling dozens of tool endpoints, or writing text-to-SQL against production data, is how agent code turns into mostly glue, and how a straightforward question turns into a multi step tool chain. Text-to-SQL on live OLTP data also carries real security and reliability risk: it's one bad query away from a production incident.

  This session adds the Context Retriever, so the agent can navigate connected business entities, customer, order, item, in a single turn, against a schema defined once. We'll walk through what that schema looks like, how the agent uses it to traverse relationships without extra tool calls, and where this replaces a tool zoo outright.
  

  Samuel Agbede
• Session 4
  Semantic caching: Making cost part of the architecture

  Every repeat query hitting the LLM at full price adds up fast, and it's usually finance who notices first, after the AI line item has already tripled. Most teams treat this as a budget problem to fix later. It's actually a design decision that belongs in the architecture from the start.

  This session adds Redis semantic caching, so repeat and near duplicate queries get served from cache instead of hitting the model again. We'll cover how semantic matching decides what counts as a repeat query, where the savings show up first, and the Mangoes.ai result: a 70% reduction in LLM spend using this same approach.

  Samuel Agbede
• Session 5
  Your context aware apps

  Four capabilities, one runtime, no seams. This closing session pulls search, Agent Memory, Context Retriever, and semantic caching into the finished context aware app built across the series, then steps back to look at how running one runtime instead of a fragmented stack of point solutions, a vector database here, a memory service there, a CDC pipeline somewhere else, changes what a team has to build, operate, and support.

  We'll also cover a few real use cases where this pattern applies directly: customer support agents that need memory and fresh order data, fraud checks that need an answer before the transaction clears, and voice agents working inside a strict turn taking budget.