The MongoDB Podcast

Watch this episode as a video on Spotify!
In this episode of the MongoDB Podcast, host Jesse Hall sits down with Karthik Kalyanamaran, Co-Founder and CTO of Langtrace AI, to discuss how engineering teams are building reliable AI products. Moving from traditional, deterministic software engineering to the non-deterministic world of Large Language Models requires an entirely new approach to debugging, testing, and monitoring.
Karthik shares his journey from scaling observability infrastructure at Coinbase to creating Langtrace AI, an open-source LLM application observability platform built on OpenTelemetry standards. We dive deep into what a modern AIOps stack looks like and how developers can eliminate the guesswork of LLM hallucinations, prompt adjustments, and vector database performance.
Key topics discussed in this episode:
The Shift to Non-Deterministic Software: Why traditional unit tests fail when building with LLMs, and how to adapt your development and production lifecycle.

The Core Elements of AIOps: A breakdown of modern AI deployment, including runtime tracing, prompt engineering, and context optimization.

Optimizing Vector Databases: How Langtrace integrates with MongoDB Atlas Vector Search to track aggregate pipelines, embedding queries, and semantic retrieval accuracy.

Anonymization and Security: Navigating SOC 2 Type 2 compliance and tracing system performance without exposing sensitive customer data.

The HTML Era of AI: Why starting with primitive, native constructs directly on top of models often yields better design insights than over-relying on complex frameworks.

Introducing Hey Zest: A sneak peek into Langtrace closed beta agent platform that allows developers to deploy B2B AI bots natively inside Slack.

Timestamps:00:06 Welcome to MongoDB Podcast Live with host Jesse Hall and Karthik Kalyanamaran00:55 Karthik background: From building infrastructure at Coinbase to launching Langtrace AI02:05 What is Langtrace? Solving the non-deterministic nature of LLMs04:17 The Origin Story: Realizing AI needs robust observability while building a crypto chatbot07:38 Transitioning from reactive traditional web2 monitoring to proactive AI Ops10:54 Defining the modern AI Engineer and the art of Context Engineering12:20 Security at scale: Navigating SOC 2 Type 2 compliance across data vendors like MongoDB14:57 Live Demo: Setting up OpenTelemetry tracing on top of a MongoDB Atlas Vector Search script16:44 Tracking latency, token count metrics, and indexing properties at runtime18:22 Implementing automated evaluations using LLM as a Judge22:05 Future Outlook: Mitigating long context window degradation and advanced tool calling23:05 Developer Advice: Why you should build closer to the bare metal model constructs24:52 Closing remarks, GitHub open source contributions

Watch this episode in Video Format on Spotify.

Are autonomous agents about to replace your traditional CRM? In this episode, Anaiya Raisinghani (Sr. Tech. Evangelist, AI Startups & Ventures at MongoDB) sits down with Ishan Mukherjee, Co-Founder and CEO of ROX. They dive under the hood of ROX, the world’s largest-scale revenue agent company that is building AI to handle the end-to-end revenue cycle autonomously.Ishan breaks down his founder journey—from Amazon Robotics to Apple's Knowledge Graph—and opens up about the technical realities of building AI agents today.What you’ll learn in this episode:
The AI Agent Architecture: Discover ROX's "three-layered cake" approach, including their context system, Agent Swarms, and application layer.
The Database Migration: Why ROX started on DynamoDB for speed but ultimately migrated to MongoDB to handle massive spikes and unstructured data at scale.
Agents vs. SaaS: The fundamental difference between traditional SaaS platforms (where humans do the work) and autonomous agents (where the AI does the outreach, research, and contracts).
 Advice for AI Founders: Why you need to be highly opinionated about your architecture but extremely iterative with your product experience.
⏱️ Chapter Timestamps
00:00 - Intro & Ishan's Journey
 01:57 - What is ROX?
 04:52 - ROX's Technical Architecture
 06:56 - Migrating to MongoDB
 08:17 - Why Context is King
 11:13 - Internal AI Adoption
 13:05 - The Future of AI and B2B
 14:33 - Lightning Round

Watch this episode as a video on Spotify!
In this episode, Luis Pazmino, Industry Principal for Financial Services at MongoDB, sits down with Saurabh Khandelwal from Capgemini to explore how financial institutions can transform payments data into a strategic revenue engine.
The conversation dives into GenPAL, Capgemini’s solution powered by MongoDB’s modern data platform, and how it enables organizations to move beyond data storage toward real-time intelligence, AI-driven insights, and data monetisation.
In this episode, we discuss:
• Evolving Payments Landscape: Key shifts shaping data strategies and opportunities in payments
• Modern Data Foundations: Building scalable, real-time architectures to support high-volume transactions and compliance needs
• From Data to Value: Turning payments data into actionable insights and new revenue streams
• AI at Scale: Leveraging gen AI and agentic AI for fraud detection, customer intelligence, and operational efficiency
• Pragmatic Modernization: How to adopt AI and modern data platforms without a “big bang” approach
Whether you’re a fintech innovator or a financial institution navigating legacy systems, this episode offers practical insights on unlocking the full value of payments data with AI and modern data platforms.

Timestamps
00:09 – Introduction

01:05 – Introducing GenPAL

02:38 – The tactical shift: From standard BI to Agent AI

04:56 – Identifying strains

06:59 – Solving payment failures

08:48 – Sub-millisecond latency

12:48 – The "Experience Gap"

15:01 – Strategic advice

18:14 – High-level architecture

21:35 – Real-world success

24:09 – Future outlook

Watch this episode in video format on Spotify!
If you're building Python applications on MongoDB and still writing raw queries by hand, you're leaving a lot of developer productivity on the table. Beanie, the async-first ODM built on Pydantic, was created to fix exactly that — and this episode goes deep on how and why it works.
You'll learn how Beanie maps Python objects to MongoDB documents without sacrificing atomicity or performance, why async-first design matters for modern Python stacks, how schema migrations actually work in a document database, and what the deprecation of Motor means for your existing codebase. The episode also covers Beanie's integration with FastAPI, how it handles indexes and aggregation pipelines under the hood, and what's coming in the next phase of the library.
Ramon, the creator of Beanie and a senior software engineer at Microsoft, built this library five years ago to fill a gap nobody else had addressed. He's joined by Shubham, MongoDB's product manager for Python client libraries, for a live demo and Q&A.
Follow The MongoDB Podcast so you never miss an episode.
-
[00:00] Introduction & Guest Welcome
[01:00] What Is Beanie? The ODM Explained
[04:10] ODM vs ORM — What's the Difference?
[05:20] Why Ramon Built Beanie (The Origin Story)
[06:30] Core Design Principles: Atomicity & Async-First
[08:00] FastAPI + MongoDB: The Rising Python Stack
[11:00] Bonnet: The Synchronous Beanie Backport
[12:55] Live Demo: Defining Document Schemas with Pydantic
[16:00] Nested Documents, Links & Polymorphic Collections
[18:45] Best Practices for Schema Design
[20:30] Index Management in Beanie
[22:40] Complex Queries: Beanie vs Raw PyMongo
[24:30] Aggregation Pipelines in Beanie
[28:05] Schema Migrations: Forward, Backward & Freefall
[31:30] Motor Is Deprecated — What That Means for You
[34:00] Beanie v2: What Changed and What Didn't
[36:20] FastAPI, Flask & Django Integration
[37:45] What's Next for Beanie: Performance & Lambda Optimization
[39:30] How to Contribute to Beanie
[41:00] Resources, Community & Audience Q&A

Are you still relying on OCR for your enterprise AI? You're losing critical context.
In this episode, Anaiya Raisinghani (Sr. Tech. Evangelist, AI Startups & Ventures at MongoDB) sits down with Adityavardhan Agrawal, Co-Founder and CEO of Morphik. They dive deep into how Morphik is helping developers and enterprises understand complex, unstructured data and automate high-leverage workflows.
Adi breaks down the limitations of standard RAG pipelines and reveals why they turned to Vision Language Models (VLMs) to process complex documents like architectural floorplans.
What you’ll learn in this episode:
The OCR Trap: Why text extraction is inherently lossy for complex documents and how VLMs generate better embeddings.

The RAG Misconception: Why getting high-quality context requires much more than just plain vector search.

Database Architecture: Why Morphik hit the limits of Postgres/JSONB for dynamic datasets and how migrating to MongoDB Atlas simplified their multi-tenancy and querying.

Massive ROI: How one manufacturing customer used Morphik to slash their quote generation time from 7 days to under 2 minutes.

The Future of Knowledge: Building self-healing, self-updating data layers that leverage MQL.

(Want to start building? You can use Morphik's API, Python/TypeScript SDKs, or grab the Docker image from GitHub today!)

⏱️ Chapter Timestamps
00:00 - Intro: Meet Adi and Morphik

01:18 - APIs, SDKs, and Getting Started with Morphik

02:28 - The Lightbulb Moment: Why Standard AI Fails on Unstructured Data

04:44 - The Biggest Misconception About RAG

06:24 - Vision Language Models (VLMs) vs. Traditional OCR

08:35 - Reducing Entropy: Combining Embeddings with Knowledge Graphs

10:13 - Architecture Deep-Dive: Hitting the Limits of Postgres & JSONB

12:06 - Why Morphik Migrated to MongoDB Atlas

13:24 - Simplifying Multi-Tenancy at Scale

15:13 - Ensuring Data Security and Reliability

16:33 - Accelerating Growth with MongoDB for Startups

18:10 - Real-World Impact: Cutting Quote Generation from 7 Days to 2 Minutes

20:15 - The Future: Self-Healing Data Layers and Native MQL