Technology Explorations in Data & AI

AI is only as good as the layer underneath it. That layer in Databricks is called a Metric View: a semantic model that defines your measures, your joins, and the rules for how data fits together. In this episode, Stefan walks through the full stack end-to-end on a real LEGO dataset: building Metric Views in Databricks, generating them with dbt, deploying through Databricks Asset Bundles, and finally exposing it all through a Genie Space that business users can chat with. Along the way we get into some deeper questions:  what the limits of metric views look like, how access control works, what BI "shifting left" actually means for engineering teams, and how you organize this in data products.If you saw our Snowflake Intelligence episode, this is the Databricks counterpart. The Snowflake episode can be found here: https://www.youtube.com/watch?v=Gp-BntPgpcUResources:- Demo code: https://github.com/datamindedbe/demo-technology-exploration- [episode-specific links here]Creators & Guests Jonny Daenen - Host Stefan Van Raemdonck - Guest ---Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb(00:00) - Chapter 1 (00:00) - Intro (00:50) - Meet Stefan (01:43) - Demo: talking to your LEGO data (07:17) - Why semantic layers? Data products explained (11:20) - What's in a metric view? (14:15) - Creating Metric Views in Databricks (16:29) - The LEGO data model (18:17) - Data Products & Metric Views in Databricks (22:07) - Are we limited to predefined measures? (23:16) - Building: native Databricks SQL bundles (29:12) - Building: dbt (31:16) - Maintenance and BI shifting left (33:59) - Deploying dbt on Databricks (35:29) - Creating the Genie Space (38:24) - Access Control and Permissions in Data Queries (39:28) - Writing SQL on top of Metric Views (40:10) - Takeaways and favorite Lego ---Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Your dashboards only answer the questions you thought of last quarter. Every new question is a ticket, a dependency, or a gut call. Snowflake Intelligence wants to fix that -- a chat interface on top of governed enterprise data that turns plain English into SQL, runs it, and gives you a chart back. No analysts involved.Jelle builds the full setup live: semantic view, verified queries, Cortex Agent, access control. They get honest about what this actually requires -- data quality, governance, and whether Snowflake is worth the cost.Resources:- Snowflake Intelligence docs: https://docs.snowflake.com/en/user-guide/snowflake-intelligence- Demo code: https://github.com/datamindedbe/demo-technology-explorationCreators & Guests Jonny Daenen - Host Jelle De Vleminck - Guest ---Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb---Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Enterprise data is full of sensitive information: different teams, different access rights, different rules. When you ask an AI agent a simple question and get "access denied," it's not a permissions bug. It's a design problem.Pascal has been exploring how to tackle this using Agno, an agent framework built around deterministic workflows. Instead of letting a single agent roam freely across your data, Agno lets you build specialized agents, each with its own access rules and instructions. Workflows orchestrate these agents with guardrails that keep humans in the loop when it matters.In this episode, Pascal Knapen, CTO at Dataminded, demos the full flow: from a natural language question, through an access check, to a verified answer. We explore how skills differ from workflows, how Agno handles dynamic agent creation and deployment, and how LLM-based evaluations act as a quality judge for agent responses.Additional Resources:Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/agno-workflowsCreators & Guests Pascal Knapen - Guest Jonny Daenen - Host ---Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb(00:00) - Intro: AI agents and enterprise data (01:50) - Two ways to give AI access to your data (03:23) - Skills vs Workflows (04:45) - Demo: AI with controlled data access (07:45) - The workflow is deterministic - the agents aren't (09:13) - Demo: evaluations & reliability (11:00) - Code walkthrough with Agno (17:45) - Why Agno? An honest take (19:46) - Identity & exposing as an API (20:24) - Takeaways ---Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Jan opens 12 browser tabs every morning to check overnight pipelines. Log in, check, close. Twelve times. So he built a terminal app instead.Flowrs is a TUI for Apache Airflow written in Rust. Navigate all your environments from the keyboard, drill into failed tasks, tail live logs, bulk-mark runs -- no browser, no mouse. In this episode Jan demos it live, walks through the architecture of a TUI (event loop, state, render), compares the main frameworks (Ratatui, Bubble Tea, Textual), and gives his honest take on whether agents will eventually replace tools like this."Go forth and mulTUIply. Life is too short to click around."Resources:- Install Flowrs: brew install flowrs- GitHub: https://github.com/janbvanbuel/flowrs---Creators & Guests Jonny Daenen - Host Jan Vanbuel - Guest Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb(00:00) - Introduction (01:17) - What is Flowrs & Airflow? (03:27) - Demo: Flowrs in action (10:18) - The evolution of CLIs and TUIs (13:07) - Why not just use agents? (14:25) - TUI frameworks: Bubble Tea, Textual, Ratatui (15:21) - What's up with the Rust hype? (16:51) - Building the Flowrs UI (19:20) - How to install Flowrs yourself (22:34) - Takeaways & what's next ---Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Every time you ask AI for help, it agrees. Fast, confident, and it never tells you your plan has holes. That's the problem Arete is built to fix.Jesus built a brainstorm agent on Claude Code skills that guides you through five phases -- Ground, Explore, Decide, Stress, Ship -- before you commit to anything. The output is an architectural decision record and an implementation plan you actually own.In this episode he demos it live, shows how parallel subagents work without polluting your main context, and answers the honest questions: tokens burned, vendor lock-in, debugging subagents, and whether this works with a team.Resources:- Install Arete: https://github.com/jesgarram/arete- Demo code: https://github.com/datamindedbe/demo-technology-exploration---Creators & Guests Jonny Daenen - Host Jesús García Ramírez - Guest Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb(00:00) - Intro & meeting Arete (01:38) - The 5-step brainstorm workflow (04:05) - Meta: This video was made with an AI skill (06:02) - The demo: ground, explore, decide, stress, ship (14:56) - Example results: ADR and Plan (17:23) - Subagents and context engineering (21:12) - Demo: the Researcher Agent (22:48) - Practical concerns: vendor, files, big projects (25:30) - How many tokens does it burn? (26:51) - Control, agents vs skills, multi-human (29:44) - How to install Arete (30:44) - Wrap-up ---Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

AI agents get messy fast once you move beyond simple prompts. Context windows fill up with noise, agents start reasoning in loops, and suddenly you're dealing with brittle behavior and hallucinations.Jesus walks through how Claude Code skills fix this -- packaging repeatable workflows into modular components that load only when needed. He demos two real examples: an Explain Code skill and a PR Review skill that forks context, limits tool permissions, and uses CLI commands to analyze pull requests.Resources:- Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/agent_skills- Anthropic docs: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview- Skills standard: https://agentskills.io- Curious about MCP? https://youtu.be/fIr55-koOJQ---Creators & Guests Jonny Daenen - Host Jesús García Ramírez - Guest Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnb(00:00) - Introduction (01:28) - Demo: Skills in Claude Code (05:57) - How agents work: from prompts to context engineering (08:19) - What are Skills? (vs MCP, RAG, Commands) (10:33) - Building your own Skill (15:20) - Skills vs MCPs (16:29) - What about hallucinations? (17:07) - Specs and Anthropic's Skill Guide (19:28) - Skillception: a skill to create skills (20:34) - Is MCP history? (22:50) - Sharing skills & wrap-up ---Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Azure Log Analytics costs often take up 20% or more of a cloud bill, even though most teams only check logs when something breaks.Azure's default analytics logs are powerful, but they're also expensive and often unnecessary for day-to-day log inspection. Switching application logs to Basic Logs can reduce Log Analytics costs by up to 60%.In this episode, Niels walks us through a real customer case where logging costs dropped by thousands per year. They explain the difference between Analytics, Basic, and Auxiliary logs, show when Basic Logs are sufficient, and discuss practical setups using Azure Container Insights and FluentBit. This includes building a custom FluentBit plugin in Go as well as real-world gotchas like missing short-lived pods and why dynamic credentials matter.Creators & Guests Jonny Daenen - Host Niels Claeys - Guest Resources:Custom FluentBit plugin: https://github.com/nclaeys/fluent-bit-go-azureClick here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbChapters:(00:00) - Intro: why optimize Azure log costs? (03:10) - What kind of logs are we dealing with? (06:13) - Plan types & the cost difference (09:59) - FluentBit vs Azure Container Insights (13:33) - How FluentBit works in K8S (16:41) - Can you lose log data? (17:36) - A custom plugin for Azure Workload Identity (21:05) - Why not use Azure Container Insights? (22:35) - Do all clients benefit? (23:41) - Summary & takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Code reviews are often considered a pain, resulting in quick approvals and bugs reaching production. CodeRabbit and Sourcery aim to solve this by letting an AI agent review your changes early on.In this episode, data & platform engineer Hannes De Smet shows Jonny what he learned after exploring several AI Code Reviewers. Hannes demos both tools on a real code change, allowing a critical look at the quality of the suggestions, as well as the user experience. It turns out that, depending on the context, both could use some improvements.Resources:CodeRabbit: https://www.coderabbit.aiSourcery: https://www.sourcery.ai/Multi-workspace AI video: https://www.youtube.com/watch?v=E_kOAvmeTJ0Note: This video is not sponsored or affiliated with CodeRabbit or Sourcery.Creators & Guests Jonny Daenen - Host Hannes De Smet - Guest Resources:Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbChapters:(00:00) - Intro: why AI code reviews? (02:53) - AI Reviewer 1: CodeRabbit (10:32) - What CodeRabbit catches (and misses) (12:18) - When AI comments become noise (80% disregard) (13:27) - Catching a PII issue (15:15) - AI Reviewer 2: Sourcery (19:14) - Cost & comparison (19:59) - What's the future of AI code reviews? (20:41) - Summary & takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Emil shows how to let his Cursor AI access and manipulate multiple projects at the same time.He does this by leveraging the Cursor Workspace feature, which enables you to link multiple repositories together. His demo shows how to increase application resources, which also needs a Terraform change in a second project. Along the way, we discover how important human involvement still is...You'll learn how to:Set up Cursor workspaces with multiple projectsLet your agent access and manipulate multiple codebasesLeverage best practices from previous projectsBe mindful that human involvement is still importantResources:VSCode Workspace feature: https://code.visualstudio.com/docs/editing/workspaces/workspacesCursor Rules docs: https://cursor.com/docs/context/rulesMCP 101: https://www.youtube.com/watch?v=fIr55-koOJQPostgres MCP in Cursor: https://www.youtube.com/watch?v=tbrR21I3jJIClick here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbCreators & Guests Jonny Daenen - Host Emil Krause - Guest Chapters:(00:00) - Intro & setting up a Cursor Workspace (03:21) - Demo: upgrading application memory (06:46) - Did we cheat? (08:16) - When are Workspaces most useful? (09:37) - Out with monorepos for data products? (10:15) - Best practices + read-only repos (12:17) - Learning & exploring codebases (13:24) - How Emil solved a production incident (14:40) - The future of monorepos? (15:54) - How this works with Cursor Rules (17:21) - Summary & takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

In this Technical Exploration, Jonny and Tarik show how to build a fully functioning RAG-based AI agent using MindsDB, turning internal data from Postgres, Slack, or Google Drive into a queryable knowledge base powered by semantic search.You'll see how to:Convert internal documents into a semantic knowledge baseMake Google Drive & Slack data queryable in minutesBuild a custom AI Agent on top of your knowledge basesRun MindsDB locally with DockerUse SQL to configure agents, connectors, and knowledge basesExpose your agent through a simple API for app integrationWe also touch on:Chunking & embedding strategiesLocal vs. cloud LLMsHow MindsDB compares to full ETL approachesResources:Demo code: https://github.com/datamindedbe/demo-technology-exploration/Previous episode (PyAirbyte): https://youtu.be/eLUQrSqP-nsClick here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbNote: This video is not sponsored or affiliated with MindsDB.Creators & Guests Jonny Daenen - Host Tarik Jamoulle - Guest Chapters:(00:00) - Intro: What is MindsDB? (02:03) - Scope and dataset (03:08) - Quick tour: connectors & UI (06:34) - Components: Source, Knowledge Base & Agent (06:55) - Agent demo + how MindsDB queries data (08:36) - The code: getting MindsDB running (11:27) - Q&A: embedding times & creating your agent (14:03) - A Slack agent in 5 minutes (17:19) - Multi-knowledge-base agents (18:23) - Q: Integrating with SDK & MCP (19:31) - Takeaways Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Move your Google Drive documents straight into Postgres using Python and PyAirbyte. In this Technical Explorations episode, Jonny and Tarik from Dataminded show how they ingest internal meeting transcripts (Facts at Breakfast, Learning Over Lunch) from Google Drive into a relational table, ready for querying and AI use cases.You'll see how to:Configure PyAirbyte to read from a Google Drive folderAuthenticate with a Google service account (JSON key)Convert Airbyte output into a clean pandas DataFrameLoad the processed data into a Postgres tableDiscuss performance limits, API rate limits, and batchingReflect on when PyAirbyte is great for PoCs vs. production setupsWe also touch on:How many connectors Airbyte offers and what PyAirbyte can reuseTrade-offs of code-first ingestion vs. point-and-click UIIdeas for the next step: using MindsDB and LLMs to query this knowledge baseResources:Demo code: https://github.com/datamindedbe/demo-technology-exploration/Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbCreators & Guests Jonny Daenen - Host Tarik Jamoulle - Guest Chapters:(00:00) - Intro (01:18) - What is Airbyte? (and 600+ connectors) (04:11) - Demo: Google Drive → Postgres (09:22) - Q: How do you get the table structure? (10:43) - Scale & format limits (many files, PDFs, images) (12:45) - Setting up Google Drive: auth & permissions (14:44) - Running it in production: Airflow + Docker (15:15) - Next up: MindsDB + verdict Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Emil Krause & Jonny Daenen explore how to accelerate dbt development by integrating MCP (Model Context Protocol) with Postgres and Cursor. Emil demonstrates how to solve a database bug by allowing AI agents to interact directly with databases. They discuss the setup of a database MCP server, demonstrate its capabilities in troubleshooting data inconsistencies, and highlight the importance of understanding data even when using advanced tools. The conversation also touches on the potential pitfalls of using such tools and the need for technical expertise in leveraging them effectively.Resources:Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/postgres_mcpMCP 101: https://www.youtube.com/watch?v=fIr55-koOJQClick here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbCreators & Guests Jonny Daenen - Host Emil Krause - Guest Chapters:(00:00) - Introduction: MCP + Postgres (02:20) - Demo: debugging salary percentiles (06:29) - Creating and testing dbt models (07:11) - Benefits and dangers of AI assistance (09:42) - Setting up Postgres MCP in Cursor (12:57) - Challenges & pitfalls (14:54) - MCP vs semantic models (17:16) - Other dev tasks (18:39) - Claude Desktop vs Cursor (19:59) - Summary Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

In this special episode on the AWS outage, Stijn De Haes explains what happened during the AWS October 2025 Outage. He then zooms in on the limited effect it had on Dataminded and its product Conveyor. Finally, Stijn gives 4 tips on how to protect yourself from this kind of outage.Resources:Blog post: https://hubs.li/Q03PQKrR0Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbCreators & Guests Jonny Daenen - Host Stijn De Haes - Guest Chapters:(00:00) - Intro (00:33) - What happened in the AWS outage? (05:04) - How the outage affected Dataminded (08:31) - 4 mitigations to protect yourself (11:53) - Tabletop exercises for preparedness (13:51) - Summary Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

In this conversation, Jonny Daenen and Pierre Crochelet explore the Model Context Protocol (MCP), a framework that enhances AI assistants by allowing them to perform various tasks through tools, resources, and prompts. They discuss the architecture of MCP, how to build an MCP server, and the developer flow for creating tools. The conversation also touches on the compatibility of MCP with different AI agents and the user experience, highlighting both the potential and limitations of the protocol.Resources:Demo code: https://github.com/datamindedbe/demo-technology-exploration/tree/main/demos/claude_mcpMCP servers: https://github.com/modelcontextprotocol/serversMCP directory: https://mcp.so/Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbCreators & Guests Jonny Daenen - Host Pierre Crochelet - Guest Chapters:(00:00) - Introduction (01:03) - Demo: Claude Desktop & MCP (04:43) - What is the Model Context Protocol? (07:09) - Tools, Resources & Prompts (08:20) - The protocol: Host-Client-Server (11:05) - Building your own MCP server (16:46) - Prompts, resources & tool functionality (19:45) - Developer flow & the Inspector (23:31) - Function limitations & return types (26:34) - Testing the tool & integrating other agents (28:46) - Community MCP servers & current limitations (32:11) - Summary & next steps Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay

Emil Krause and Jonny Daenen explore the claim that speech-to-text makes you three times as fast. Emil shows the functionalities and benefits of SuperWhisper and Whisper Assistant, two innovative speech-to-text tools designed to enhance productivity. They discuss the installation process, user experience, and the accuracy of these tools. Emil shares insights on how these tools can streamline workflows, particularly for those who frequently interact with AI, and emphasizes the importance of context in dictation. It turns out that SuperWhisper gives much better accuracy when it comes to technical terms.Resources:Whisper Assistant: https://marketplace.visualstudio.com/items?itemName=MartinOpenSky.whisper-assistantSuperWhisper: https://superwhisper.com/Click here to watch a video of this episode. Full playlist: https://www.youtube.com/playlist?list=PLJ_da7qdfL80rA7byzC_CmyrfJWjcCTnbNote: This video is not sponsored or affiliated with Whisper Assistant or SuperWhisper.Creators & Guests Jonny Daenen - Host Emil Krause - Guest Chapters:(00:00) - Intro: Whisper Assistant vs SuperWhisper (03:17) - Demo: Whisper Assistant (07:27) - Demo: SuperWhisper (10:24) - File tagging (12:01) - Personal take: which one for you? (14:17) - Installation & setup (17:09) - Final thoughts & recommendations Data & AI: Technology Explorations is a biweekly show from Dataminded. Each episode a Dataminded engineer demos a tool or technique worth knowing about -- working code, honest takes, no hype.Music by Aleksandr Karabanov from Pixabay