Discover how the Model Context Protocol (MCP) is revolutionizing AI systems integration by simplifying complex multi-tool interactions into a scalable, open standard. In this episode, we unpack MCP’s architecture, adoption by industry leaders, and its impact on engineering workflows.

In this episode:

- What MCP is and why it matters for AI/ML engineers and infrastructure teams

- The M×N integration problem and how MCP reduces it to M+N

- Core primitives: Tools, Resources, and Prompts, and their roles in MCP

- Technical deep dive into JSON-RPC 2.0 messaging, transports, and security with OAuth 2.1 + PKCE

- Comparison of MCP with OpenAI Function Calling, LangChain, and custom REST APIs

- Real-world adoption, performance metrics, and engineering trade-offs

- Open challenges including security, authentication, and operational complexity

Key tools & technologies mentioned:

- Model Context Protocol (MCP)

- JSON-RPC 2.0

- OAuth 2.1 with PKCE

- FastMCP Python SDK, MCP TypeScript SDK

- agentgateway by Solo.io

- OpenAI Function Calling

- LangChain

Timestamps:

00:00 — Introduction to MCP and episode overview

02:30 — The M×N integration problem and MCP’s solution

05:15 — Why MCP adoption is accelerating

07:00 — MCP architecture and core primitives explained

10:00 — Head-to-head comparison with alternatives

12:30 — Under the hood: protocol mechanics and transports

15:00 — Real-world impact and usage metrics

17:30 — Challenges and security considerations

19:00 — Closing thoughts and future outlook

Resources:

• "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition
• This podcast is brought to you by Memriq.ai - AI consultancy and content studio building tools and resources for AI practitioners.

Unlock the secrets to evaluating Retrieval-Augmented Generation (RAG) pipelines effectively and efficiently with ragas, the open-source framework that’s transforming AI quality assurance. In this episode, we explore how to implement reference-free evaluation, integrate continuous monitoring into your AI workflows, and optimize for production scale — all through the lens of Keith Bourne’s comprehensive Chapter 9.

In this episode:

- Overview of ragas and its reference-free metrics that achieve 95% human agreement on faithfulness scoring

- Implementation patterns and code walkthroughs for integrating ragas with LangChain, LlamaIndex, and CI/CD pipelines

- Production monitoring architecture: sampling, async evaluation, aggregation, and alerting

- Comparison of ragas with other evaluation frameworks like DeepEval and TruLens

- Strategies for cost optimization and asynchronous evaluation at scale

- Advanced features: custom domain-specific metrics with AspectCritic and multi-turn evaluation support

Key tools and technologies mentioned:

- ragas (Retrieval Augmented Generation Assessment System)

- LangChain, LlamaIndex

- LangSmith, LangFuse (observability and evaluation tools)

- OpenAI GPT-4o, GPT-3.5-turbo, Anthropic Claude, Google Gemini, Ollama

- Python datasets library

Timestamps:

00:00 - Introduction and overview with Keith Bourne

03:00 - Why reference-free evaluation matters and ragas’s approach

06:30 - Core metrics: faithfulness, answer relevancy, context precision & recall

09:00 - Code walkthrough: installation, dataset structure, evaluation calls

12:00 - Integrations with LangChain, LlamaIndex, and CI/CD workflows

14:30 - Production monitoring architecture and cost considerations

17:00 - Advanced metrics and custom domain-specific evaluations

19:00 - Common pitfalls and testing strategies

20:30 - Closing thoughts and next steps

Resources:

- "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition

- Memriq AI: https://Memriq.ai

- ragas website: https://www.ragas.io/

- ragas GitHub repository: https://github.com/vibrantlabsai/ragas (for direct access to code and docs)

Tune in to build more reliable, scalable, and maintainable RAG systems with confidence using open-source evaluation best practices.

Agent engineering is rapidly emerging as a pivotal discipline in AI development, promising autonomous LLM-powered systems that can perceive, reason, and act in complex, real-world environments. But is this truly a new engineering frontier or just a rebranding of existing ideas? In this episode, we dissect the technology, tooling, real-world deployments, and the hard truths behind the hype.

In this episode:

- Explore the origins and "why now" of agent engineering, including key advances like OpenAI's function calling and expanded context windows

- Break down core architectural patterns combining retrieval, tool use, and memory for reliable agent behavior

- Compare leading frameworks and SDKs like LangChain, LangGraph, AutoGen, Anthropic Claude, and OpenAI Agents

- Dive into production case studies from Klarna, Decagon, and TELUS showing impact and ROI

- Discuss the critical challenges around reliability, security, evaluation, and cost optimization

- Debate agent engineering vs. traditional ML pipelines and best practices for building scalable, observable agents

Key tools & technologies mentioned: LangChain, LangGraph, AutoGen, Anthropic Claude SDK, OpenAI Agents SDK, Pinecone, Weaviate, Chroma, FAISS, LangSmith, Arize Phoenix, DeepEval, Giskard

Timestamps:

00:00 - Introduction & episode overview

02:20 - The hype vs. reality: failure rates and market investments

05:15 - Why agent engineering matters now: tech enablers & economics

08:30 - Architecture essentials: retrieval, tool use, memory

11:45 - Tooling head-to-head: LangChain, LangGraph, AutoGen & SDKs

15:00 - Under the hood: example agent workflow and orchestration

17:45 - Real-world impact & production case studies

20:30 - Challenges & skepticism: reliability, security, cost

23:00 - Agent engineering vs. traditional ML pipelines debate

26:00 - Toolbox recommendations & engineering best practices

28:30 - Closing thoughts & final takeaways

Resources:

- "Unlocking Data with Generative AI and RAG" second edition by Keith Bourne - Search for 'Keith Bourne' on Amazon

- Memriq AI: https://memriq.ai

Thanks for tuning into Memriq Inference Digest - Engineering Edition. Stay curious and keep building!

Discover how the Natural Language Understanding (NLU) layer transforms traditional web apps into intelligent AI chatbots that understand open-ended user input. This episode unpacks the architectural shifts, business implications, and governance challenges leaders face when adopting AI-driven conversational platforms.

In this episode:

- Understand the strategic role of the NLU layer as the new ‘brain’ interpreting user intent and orchestrating backend systems dynamically.

- Explore the shift from deterministic workflows to probabilistic AI chatbots and how hybrid architectures balance flexibility with control.

- Learn about key AI tools like Large Language Models, Microsoft Azure AI Foundry, OpenAI function-calling, and AI agent frameworks.

- Discuss governance strategies including confidence thresholds, policy wrappers, and human-in-the-loop controls to maintain trust and compliance.

- Hear real-world use cases across industries showcasing improved user engagement and ROI from AI chatbot adoption.

- Review practical leadership advice for monitoring, iterating, and future-proofing AI chatbot architectures.

Key tools and technologies mentioned:

- Large Language Models (LLMs)

- Microsoft Azure AI Foundry

- OpenAI Function-Calling

- AI Agent Frameworks like deepset

- Semantic Cache and Episodic Memory

- Governance tools: Confidence thresholds, human-in-the-loop

Timestamps:

00:00 - Introduction and episode overview

02:30 - Why the NLU layer matters for leadership

05:15 - The big architectural shift: deterministic to AI-driven

08:00 - Comparing traditional web apps vs AI chatbots

11:00 - Under the hood: how NLU, function-calling, and orchestration work

14:00 - Business impact and ROI of AI chatbots

16:30 - Risks, governance, and human oversight

18:30 - Real-world applications and industry examples

20:00 - Final takeaways and leadership advice

Resources:

- "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition

- Visit Memriq at https://Memriq.ai for more AI insights and resources

Unlock the next level of Retrieval-Augmented Generation with full memory integration in AI agents. In the previous 3 episodes, we secretly built up what amounts to a 4-part series on agentic memory. This is the final piece of that 4-part series that pulls it ALL together.

In this episode, we explore how combining episodic, semantic, and procedural memories via the CoALA architecture and LangMem library transforms static retrieval systems into continuously learning, adaptive AI.

This also concludes our book series, highlighting ALL of the chapters of the 2nd edition of "Unlocking Data with Generative AI and RAG" by Keith Bourne. If you want to dive even deeper into these topics and even try out extensive code labs, search for 'Keith Bourne' on Amazon and grab the 2nd edition today!

In this episode:

- How CoALAAgent unifies multiple memory types for dynamic AI behavior

- Trade-offs between LangMem’s prompt_memory, gradient, and metaprompt algorithms

- Architectural patterns for modular and scalable AI agent development

- Real-world metrics demonstrating continuous procedural strategy learning

- Challenges around data quality, metric design, and domain agent engineering

- Practical advice for building safe, adaptive AI agents in production

Key tools & technologies: CoALAAgent, LangMem library, GPT models, hierarchical memory scopes

Timestamps:

0:00 Intro & guest welcome

3:30 Why integrating episodic, semantic & procedural memory matters

7:15 The CoALA architecture and hierarchical learning scopes

10:00 Comparing procedural learning algorithms in LangMem

13:30 Behind the scenes: memory integration pipeline

16:00 Real-world impact & procedural strategy success metrics

18:30 Challenges in deploying memory-integrated RAG systems

20:00 Practical engineering tips & closing thoughts

Resources:

- "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition

- Memriq AI: https://memriq.ai

Unlock the power of procedural memory to transform your Retrieval-Augmented Generation (RAG) agents into autonomous learners. In this episode, we explore how LangMem leverages hierarchical learning scopes to enable AI agents that continuously adapt and improve from their interactions — cutting down manual tuning and boosting real-world performance.

In this episode:

- Why procedural memory is a game changer for RAG systems and the challenges it addresses

- How LangMem integrates with LangChain and OpenAI GPT-4.1-mini to implement procedural memory

- The architecture patterns behind hierarchical namespaces and momentum-based feedback loops

- Trade-offs between traditional RAG and LangMem’s procedural memory approach

- Real-world applications across finance, healthcare, education, and customer service

- Practical engineering tips, monitoring best practices, and open problems in procedural memory

Key tools & technologies mentioned:

- LangMem

- LangChain

- Pydantic

- OpenAI GPT-4.1-mini

Timestamps:

0:00 - Introduction & overview

2:30 - Why procedural memory matters now

5:15 - Core concepts & hierarchical learning scopes

8:45 - LangMem architecture & domain interface

12:00 - Trade-offs: Traditional RAG vs LangMem

14:30 - Real-world use cases & impact

17:00 - Engineering best practices & pitfalls

19:30 - Open challenges & future outlook

Resources:

- "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition

- Memriq AI: https://memriq.ai

nlock how Retrieval-Augmented Generation (RAG) enables AI agents to remember, learn, and personalize over time. In this episode, we explore Chapter 17 of Keith Bourne’s "Unlocking Data with Generative AI and RAG," focusing on implementing agentic memory with the CoALA framework. From episodic and semantic memory distinctions to real-world engineering trade-offs, this discussion is packed with practical insights for AI/ML engineers and infrastructure experts.

In this episode:

- Understand the difference between episodic and semantic memory and their roles in AI agents

- Explore how vector databases like ChromaDB power fast, scalable memory retrieval

- Dive into the architecture and code walkthrough using CoALA, LangChain, LangGraph, and OpenAI APIs

- Discuss engineering challenges including validation, latency, and system complexity

- Hear from author Keith Bourne on the foundational importance of agentic memory

- Review real-world applications and open problems shaping the future of memory-augmented AI

Key tools and technologies mentioned:

- CoALA framework

- LangChain & LangGraph

- ChromaDB vector database

- OpenAI API (embeddings and LLMs)

- python-dotenv

- Pydantic models

Timestamps:

0:00 - Introduction & Episode Overview

2:30 - The Concept of Agentic Memory: Episodic vs Semantic

6:00 - Vector Databases and Retrieval-Augmented Generation (RAG)

9:30 - Coding Agentic Memory: Frameworks and Workflow

13:00 - Engineering Trade-offs and Validation Challenges

16:00 - Real-World Applications and Use Cases

18:30 - Open Problems and Future Directions

20:00 - Closing Thoughts and Resources

Resources:

- "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition

- Visit Memriq AI at https://Memriq.ai for more AI engineering deep dives and resources

Unlock the future of AI agents with agentic memory — a transformative approach that extends Retrieval-Augmented Generation (RAG) by incorporating persistent, evolving memories. In this episode, we explore how stateful intelligence turns stateless LLMs into adaptive, personalized agents capable of learning over time.

In this episode:

- Understand the CoALA framework dividing memory into episodic, semantic, procedural, and working types

- Explore key tools like Mem0, LangMem, Zep, Graphiti, LangChain, and Neo4j for implementing agentic memory

- Dive into practical architectural patterns, memory curation strategies, and trade-offs for real-world AI systems

- Hear from Keith Bourne, author of *Unlocking Data with Generative AI and RAG*, sharing insider insights and code lab highlights

- Discuss latency, accuracy improvements, and engineering challenges in scaling stateful AI agents

- Review real-world applications across finance, healthcare, education, and customer support

Key tools & technologies mentioned:

Mem0, LangMem, Zep, Graphiti, LangChain, Neo4j, Pinecone, Weaviate, Airflow, Temporal

Timestamps:

00:00 - Introduction & Episode Overview

02:15 - What is Agentic Memory and Why It Matters

06:10 - The CoALA Cognitive Architecture Explained

09:30 - Comparing Memory Implementations: Mem0, LangMem, Graphiti

13:00 - Deep Dive: Memory Curation and Background Pipelines

16:00 - Performance Metrics & Real-World Impact

18:30 - Challenges & Open Problems in Agentic Memory

20:00 - Closing Thoughts & Resources

Resources:

- "Unlocking Data with Generative AI and RAG" by Keith Bourne - Search for 'Keith Bourne' on Amazon and grab the 2nd edition

- Visit Memriq.ai for more AI engineering deep dives and resources