Discover the Talks at PyCon Colombia 2026 ✨
Browse every accepted session—titles, tracks, levels, and speakers—before you plan your days in Medellín.
Building AI Agents to Play Catan
Designing AI for environments with chance and imperfect information is a fascinating challenge. In this workshop, we will develop a Python agent capable of playing Settlers of Catan and compare different approaches live. Beyond the board, attendees will discover how the principles used here apply to any LLM-based agent system. You will learn to equip your agents with tools, connect services via MCP (Model Context Protocol), and structure robust architectures to optimize complex decision-making.
Future-proof Engineers with AI-DLC
The Problem Today, many engineers have fallen into a trap: they are using Artificial Intelligence simply as a "glorified autocomplete" to write code faster, leaving architectural design aside. The real challenge arises in the real world: technical teams often do not know how to take an AI-based idea to production safely, scalably, and maintainably. The Solution: Future-proof Engineers with AI-DLC This is a practical, intensive workshop designed to break that stagnation. Our goal is for you to stop being a passive consumer of AI tools and become an architect capable of applying the AI Development Lifecycle (AI-DLC) as a structured work framework. We will teach you to take control and increase ownership in your projects. Who is it for? Mid and Senior software engineers looking to evolve their skills, master modern system design, and lead AI integration in their work teams.
Carlos Alberto Riveros Varela
Senior Software Engineer @ EPAM Systems
Jesús Alfredo Reyes Vargas
Lead Software Engineer @ EPAM Systems
High-Performance Video Ingestion with Async Python
How do you process multiple video sources in real time without saturating the CPU or losing frames along the way? In this session, we will explore how to break the limitations of traditional workflows through asynchronous architectures. We will analyze how to design an efficient pipeline in Python that achieves concurrent ingestion, processing through AI models, and persistent video storage, all in a decoupled and scalable way. We will share the technical challenges and architecture strategies to move from blocking systems to a robust, high-performance data flow. If you want to take your computer vision projects to the next level and master the power of asyncio, this session is for you.
How to Find Pearls on the Bottom of the Sea - Autoencoders as Anomaly Detection Model
In the AI/Machine Learning world, we often think of anomalies as errors that need to be fixed. But what if some of those anomalies are actually opportunities of immense value? Detecting these opportunities, these "pearls," is a huge challenge due to the vastness and complexity of the data ocean. There is a solution: anomaly detection models—positive ones in this case—and we will explore them in this session.
Executable Skills: Teaching an Agent How Your Company Works
The problem, in YC's words (February 2026): "Every company has scattered know-how — in people's heads, in old emails, in Slack threads, in support tickets, and in databases. The company works because humans vaguely remember where that knowledge is. But AI agents do not operate that way." The solution is a Company Brain: a system that extracts knowledge from all those fragmented sources, structures it, keeps it up to date, and turns it into an executable skills archive for AI. This workshop builds, in two hours, a minimal but real Company Brain with pure Python. It is not theory: the code comes from Centinela, a platform already in production serving agricultural operations in Colombia and beverage distributors in Bolivia, and combines the same pieces that at LaHaus have allowed me to bring voice agents to 2.5k+ calls/month with a real SLA. Stack we will touch (all Python or accessible from Python): - Chainlit ≥ 2.9 as conversational interface and thread/step data layer - deepagents (0.4.x) as orchestrator for stateful agentic loops - langchain-anthropic + fallback to Gemini via langchain-google-genai - e2b-code-interpreter as a real sandbox (not mock) to run Python with auditable side effects - Supabase (Postgres + RLS) as multi-tenant control plane - asyncpg for a conversation persistence layer on PostgreSQL - MCP (Model Context Protocol) via langchain-mcp-adapters to plug in external tools
Build Your AI DJ: Agents in Python and Open Source
What happens when a language model stops just talking about music and starts curating playlists with your real songs? In this workshop we build together, step by step, an AI agent that works as your personal DJ, using Python, 100% open source tools, and connected directly to Spotify. Layer by layer: from an agent that only converses, to one that searches songs, builds real playlists, and remembers your tastes. All local, all open source, all in Python. Each participant leaves with their own working agent.
From ETL to Agentic Workflows: The Evolution of Data Engineering in the Generative AI Era
This hands-on workshop will explore how data engineering is evolving from traditional ETL-based pipelines toward intelligent agent-driven systems capable of reasoning, planning, and executing tasks autonomously. Through hands-on exercises, participants will learn the fundamental concepts behind agentic workflows, the new architectural patterns emerging in the industry, and the modern Python libraries that enable building these types of solutions. Tools for agent creation, task orchestration, integration with language models, and automation of complex processes will be covered. Upon completion, attendees will have built functional examples and will understand how to apply these new capabilities to transform traditional data processes into more dynamic, autonomous, and scalable systems.
Building Your First AI Tool Server: Creating a Pokédex with FastMCP and Python
Do you want your AI applications to do more than answer questions? The Model Context Protocol (MCP) is becoming the standard for connecting language models with tools, APIs, and external systems. In this workshop you will learn to build your first MCP server using FastMCP and Python. Through a completely hands-on experience, we will explore the fundamental concepts of the protocol, how to expose tools, and how to integrate them with compatible clients such as Claude. As the main project, we will build an interactive Pokédex connected to the PokéAPI. Participants will develop real tools to query Pokémon information, expose them through an MCP server, and allow a language model to use them autonomously. Upon completion, you will have developed your own FastMCP server, understand the fundamentals of MCP, and have a solid foundation for creating AI-native applications connected to real data and services. Spots are limited... Gotta catch 'em all!
Daniel Galvis
Senior Analytics Engineer @ Aimpoint Digital
Felipe Sanchez
Analytics Consultant @ Aimpoint Digital
The Fellowship of Agentic Evaluations: How to evaluate an agent?
Autonomous agents are redefining what we can build with LLMs, allowing AI not only to respond but to reason and execute actions across complex flows. However, as we give them more autonomy with tools like LangGraph, a critical engineering problem arises: How do we know if the agent is truly reliable? In this workshop, we will address the challenge of agent evaluation. We do not want to limit ourselves to checking whether the final response sounds good, but to implement different ways of evaluating these agents, ranging from deterministic validations to metrics based on other LLMs (LLM-as-a-judge). For this exercise, we will apply these concepts to the universe of The Lord of the Rings mixed with real medical standards to validate mainly: - Data Integrity: Validate that the agent correctly extracts and formats structured medical codes. - Fidelity: evaluate that the agent does not hallucinate diagnoses. - Observability: Trace and cost monitoring with Langfuse. Upon completion, attendees will have a clear idea of how to answer the question: How to evaluate an agent?
Maria Fernanda Rojas Castro
Advanced Data Engineer @ Loka INC
Nicolas Roldan Fajardo
Advanced Machine Learning Engineer @ Loka INC
Forging Agents on AWS: Spells with Strands, MCP, and A2A
Artificial intelligence is no longer just a tool that developers use: it is a teammate they can build. In this workshop, you will discover how to forge autonomous AI agents on AWS using Strands, a framework that simplifies creating agents able to think and act on their own. We will explore how to connect these agents with external tools and services via MCP (Model Context Protocol), how to orchestrate communication among multiple agents with A2A (Agent-to-Agent), and how to design systems where several agents collaborate to solve complex problems in a coordinated way.
From S3 to AI Agent: Your First Queryable Lakehouse
AI agents are only as good as the data they can query. The problem is that most agents built today are connected to outdated CSVs, unstructured databases, or simply nothing. What if your agent could query a real lakehouse — with versioning, schema evolution, and time travel — using natural language? In this workshop we will build exactly that, from scratch, using only open source tools that run on your laptop. What we will build together: Starting from a fully local stack based on Docker Compose, we will set up a functional lakehouse architecture using MinIO as S3-compatible storage, Apache Iceberg as the table format, Project Nessie as a Git-like versioned catalog, and Trino as the SQL query engine. On top of that, we will build an MCP server in Python that exposes our Iceberg tables as tools queryable by an AI agent — and we will finish by connecting Claude so it can query our lakehouse in natural language. What you will learn: How a modern lakehouse really works under the hood — without managed services hiding the magic How Apache Iceberg enables schema evolution, time travel, and row-level deletes on object storage How to build an MCP server in Python that turns SQL queries into tools for AI agents Why this open source architecture mirrors exactly what companies like Netflix, Airbnb, and modern data teams use in production Why open source? We deliberately replace AWS S3 with MinIO, AWS Athena with Trino, and AWS Glue with Project Nessie — not because AWS is bad, but because understanding the real components makes you a better engineer, and because this workshop should be accessible to everyone, regardless of whether you have an AWS account or not. At the end of the workshop you will have a functional lakehouse running on your machine, a working MCP server, and an architecture you can take directly to your next project.
hls4ml: From Python Models to Hardware Acceleration
This session presents a journey from developing machine learning models in Python to their implementation in hardware through the hls4ml tool. The goal is to show how models built in widely used frameworks such as TensorFlow, Keras, or PyTorch can be transformed into efficient hardware descriptions for deployment on reconfigurable devices. The complete workflow will be covered, including model preparation, conversion to High Level Synthesis (HLS) code, and the main hardware optimization criteria such as quantization and precision reduction. The trade-offs between latency, energy consumption, and model accuracy will also be discussed.
Jeronimo Lopez Gomez
Estudiante, Joven Investigador @ Universidad de Antioquia, Grupo de Instrumentacion Cientifica y Microelectronica
Natalia Echeverri Durán
Estudiante @ Universidad de Antioquia, Grupo de Instrumentacion Cientifica y Microelectronica
LangGraph and Strands Agents: Core Concepts, Patterns, and Tradeoffs
The agent framework landscape has consolidated fast. Among the options available today, two stand out for their architectural depth and production relevance: LangGraph, with its graph-based, developer-controlled orchestration model; and Strands Agents, with its model-driven, minimal-scaffolding approach. They are not interchangeable — they represent different answers to the same fundamental question of how much control a developer should retain over agent behavior. This workshop is a structured, hands-on exploration of both. Participants will work through a shared codebase covering real scenarios: tool calling, state management, multi-turn reasoning, and multi-agent coordination. Each scenario is implemented in both frameworks side by side, making the architectural differences concrete and comparable rather than theoretical. The session is organized around three axes: core concepts (how each framework models state, tools, memory, and control flow), practical patterns (what each one makes easy, what it makes hard), and honest tradeoffs (where each framework earns its complexity and where it doesn't). No polished demos — just real code, real outputs, and an open discussion of what each approach costs and buys you. By the end, participants will have a working mental model for both frameworks, hands-on exposure to their key patterns, and enough grounded perspective to make an informed architectural decision on their next agentic project. Suitable for: Python developers with some familiarity with LLMs or agent concepts. Production experience is a plus but not required — the workshop is designed to reward depth of engagement, not prior framework knowledge.
Isabel Mora
Junior Machine Learning Engineer @ Loka
Jose Hernan Ortiz Ocampo
Senior Machine Learning Engineer @ Loka
Your LLM Is Bleeding Money and Python Can Stop It
You put your LLM in production. It responds, it works, users use it. But there are questions you cannot answer: how much did it cost you exactly last week? Which prompt consumes the most tokens? Why was that response terrible on Tuesday at 3pm? How do you show the business that the system is improving? Most teams working with LLMs today operate blind. They deploy, receive complaints, adjust prompts without data, and get API bills that no one can explain. That is not engineering — it is expensive intuition. In this workshop you will build, line by line in Python, a complete observability system for LLM applications using OpenTelemetry, Langfuse, and Elasticsearch. No theory, no endless slides — real code you can take to your project the following Monday. What you will build: We start from a document Q&A agent that appears functional but is completely blind. During the workshop we instrument it step by step: first with Langfuse @observe decorators to capture every prompt, response, and token count; then we export those traces via OpenTelemetry to Elasticsearch, where we build a live Kibana dashboard showing cost per user, p95 latency per model, and low-quality response rate. Finally we implement an automatic evaluation layer with LLM-as-a-judge so the system audits itself. At the end of the workshop you have a functional, open source, self-hostable stack — without depending on closed SaaS platforms — that any team can adopt regardless of whether they use OpenAI, Anthropic, or local models via Ollama. What you take away: Complete GitHub repository with Docker Compose ready to spin up the environment, notebooks with each workshop step, and an exportable Kibana dashboard template. Everything in Spanish, documented so you can share it with your team. Who is this workshop for? For Python developers who already have basic experience with LLMs and APIs, and who are ready to take the step from "my POC works" to "my production system is reliable, measurable, and defensible to the business." You do not need prior experience with OpenTelemetry or Elasticsearch — we explain them from scratch in the context of LLMs. Why does this matter now? Global spending on LLM APIs doubled in less than six months. 47% of companies are running observability pilots for AI but only 7% have it in production. The gap between making an LLM work and operating it responsibly is the most urgent technical problem the industry has today — and Python has all the tools to close it.
LLMs in Depth: How an LLM Works Mathematically (and Its Implementation with PyTorch)
Imagine a 30-minute space where mathematics, code, thought experiments, and one of the most attractive topics of the present converge during powerful minutes — that is what this presentation seeks. The goal of this talk is to review each of the components of a Large Language Model (LLM), from the embedding system and the BPE algorithm to the attention mechanism that is the core of modern AI, passing through normalization and the small "tricks" used in both training and inference to improve results and make LLMs more optimal. Each of these components will be addressed from three perspectives: 1) the pure mathematics that composes the solution, 2) the interpretation of this mathematics (why it is useful and how we can visualize it), and 3) the implementation in code, where small code snippets will show how these systems are implemented in Python. At the end, an open-source code repository will be provided with the full implementation and training pipeline for a "playground model" implementing a GPT-style model. The intention with this talk is not only to shed light on one of the most interesting and complex topics in the modern world, but also to provide tools to question how these systems work and promote research in this field.
From Notebook to Production: End-to-End MLOps on Databricks
Is your Machine Learning model trapped in a Notebook or does it actually generate value in production? Taking ML models into the real world requires more than just good training code; it demands a solid MLOps strategy. In this hands-on workshop, we will transform a use case from scratch into an industrial-grade solution using Databricks and MLflow. Through a hands-on approach and using Databricks Free Edition, attendees will master the complete lifecycle (End-to-End) under professional standards. Workshop Agenda: - Industrialization Fundamentals: Introduction to Lakehouse architecture, MLflow as an industry standard, and the role of the Feature Store in reproducibility. - Engineering and Governance: Creating a Feature Store and managing raw data with best practices. - Scalable Training: Developing models with exhaustive experiment tracking and a bonus on distributed training for large data volumes. - Deployment Strategies: Analysis of trade-offs between Batch Inferencing and Real-time Serving (Model Serving). We will implement "Deploy Code" and "Deploy Artifacts" patterns. - Modern Operationalization: Professional orchestration through Databricks Asset Bundles (DABs), the definitive tool for infrastructure as code on Databricks. - The finishing touch (CI/CD): How to integrate everything into a continuous deployment pipeline to guarantee quality across multiple environments. Outcome for attendees: Upon completion, each participant will have the source code, infrastructure configuration, and a productized, orchestrated ML model ready to be replicated in real environments.
Patterns, Protocols and Tactics for Multi-Agent Systems
As LLM applications evolve, Multi-Agent Systems (MAS) are becoming the new standard for complex automation. But how do agents effectively communicate and collaborate? This session breaks down the protocols and tactical patterns of MAS. From basic routing to advanced collaborative architectures, discover how to use Python to build systems where agents work in harmony.
Multi-Agent Teams in AI-Assisted Development: A Glimpse Into the Future of Programming
Programming has gone through a quiet but radical transformation in the last few years. We went from writing every line, to autocomplete, to AI proposing whole functions, to reviewing and steering AI-generated code. What comes next? Multi-agent systems, where you have a team of specialized agents working in parallel. This workshop is a hands-on, honest look at what that shift means today, and what it points to tomorrow. We'll start by mapping the current landscape together: what tools exist, how they approach multi-agent orchestration, what each one gets right, and where the real tradeoffs are. The goal isn't to pick a winner — it's to build a shared vocabulary and a realistic picture of the state of the art. From there, we'll move into live demos. Rather than polished showcases, these are honest explorations: what these systems can actually do today, where they break down, and what those breakdowns tell us about the deeper challenges in multi-agent coordination. Token costs, context limits, agent miscommunication, and the question of how much to trust your agents — these are real problems worth examining together. The talk closes with the bigger question: what does all of this mean for us as developers? What skills are becoming more important, which ones are becoming less so, and how do we stay relevant as the abstractions keep deepening? Not predictions, but a grounded reflection based on what's already visible in these early systems. The practical question isn’t whether this future is coming; it’s how to get ahead of it. Audience takeaways: A clear mental model for what multi-agent coding actually is (vs. single-agent tools and vs. orchestration frameworks) A working setup guide for multi agent works effectively Practical demos actually showcasing what to do with these tools A grounded perspective on what these experimental systems tell us about the next years of AI-assisted development and programming Suitable for: Python developers with some familiarity with AI tooling. No deep ML background required — this is a practical developer talk, not a research talk.
Daniel Sabogal
Data & ML Intern @ Loka
Jose Hernan Ortiz Ocampo
Senior Machine Learning Engineer @ Loka
Fine-tuning at Nequi: Teaching a Small Model the Language of Our Transactions
At Nequi, a transaction is not just an amount and a date — it is behavior, context, and sequence. Generalist models do not capture that semantics, and rigid rules do not scale with millions of users. In this workshop we explore hands-on how to fine-tune a small model so it learns the language of transactional events: their patterns, anomalies, and risk signals. Participants will work from dataset construction to model validation, understanding at each step which decisions matter and why
Angie Katherine Reyes
AI Builder & Team Lead @ Nequi
Elkin Javier Guerra Galeano
Machine Learning Engineer | MLOps @ Nequi
NLP in Practice: From Corpus Linguistics to RAG with Python
Natural language processing today offers a mature set of tools for analyzing textual corpora systematically and reproducibly, but the path between having the documents and obtaining results is not always clear. This workshop covers that path from start to finish. In two hours, participants will build an understanding of the NLP ecosystem: its history, logic, and methods. The session opens with a timeline from the earliest rule-based models to transformers, followed by a map of techniques organized by problem type (classification, entity extraction, semantic search, generation) so each participant can identify which method they need for a specific textual problem. The second part covers two implementations with Python. First, topic modeling with BERTopic, reviewing the internal pipeline of embeddings, UMAP, and HDBSCAN. Second, a conversational assistant with RAG: corpus indexing, semantic retrieval, and connection with a language model to answer queries about the documents. Upon completion, each participant will have a functional notebook with both pipelines and a clear map of the ecosystem to guide their own textual analysis projects.
Andrés Felipe Puerta Velez
Asistente de investigación y estudiante de maestría en matemáticas aplicadas. @ Universidad EAFIT
Biviana Marcela Suárez Sierra
Profesora vinculada al área de Computación y analística @ Universidad EAFIT
Dora Cecilia Alzate Gallo
Estudiante de la Maestría en Estudios Humanísticos @ EAFIT
Karen Melissa Gomez Montoya
Ingeniera matemática - Asistente en investigación @ Universidad EAFIT
NORTH: Claude as a Real Copilot
We all use AI to program. Few use it well. Most developers interact with Claude or any LLM as if it were Google with superpowers: they ask a question, receive an answer, copy and paste, unstructured prompts. The next day, the AI has no idea who you are, what project you are working on, or why you chose PostgreSQL over MongoDB last week. Every session starts from zero. Every time you re-explain the same thing. And the result is brilliant answers that do not know your code. How serious is this? I measured it. I asked Claude exactly the same thing — "give me the complete project context" — with and without methodology. Without structured context, Claude detected 3 of 5 team members, found 3 different versions of the project without knowing which was real, could not identify technical debt, and had no idea about the current sprint. With NORTH, the answer was precise: complete team with roles, correct canonical version, 3 technical debt items with severity, defined sprint with priorities, and pending PR to merge. Usefulness score: 7/7 with NORTH vs 2.5/7 without it. Same tokens. Same cost. The difference is not money — it is useful information vs noise. What if with a single command — /north — Claude knew exactly where you left off and what comes next? That is NORTH. A methodology that turns Claude into a real development copilot. Not a chatbot that answers questions — an agent with live memory of your project.
PDF Data Extraction at Scale: When to Trust an LLM
LLMs read chaotic documents like no one else, but when money or legal liability is on the line, the question is not "can it?" but "when should I trust it, and how do I catch it when it is wrong?". In this hands-on workshop we build, step by step, a real extraction pipeline for legal PDFs with variable formats, orchestrated with Airflow, using a hybrid extractor (deterministic + LLM) and deterministic guardrails in Python. You will leave with a framework for deciding which tool to use and a reliable pattern for production environments.
From Prompts to Agents: Intelligent Systems with Python
Prompts are only the beginning. The real power of modern artificial intelligence lies in transforming those instructions into structured systems capable of reasoning, applying rules, and generating consistent decisions. In this hands-on workshop, participants will go beyond basic prompt usage and learn to design and build intelligent agents using Python. Starting from a simple prompt, we will progressively evolve it into a functional agent that processes information, applies context, and generates structured responses. Through a practical approach, we will learn to: Design effective prompts with clear context, objectives, and constraints Structure responses in reliable formats (such as JSON) Build a simple agent in Python that transforms questions into decisions Incorporate context and memory to improve results Evaluate the quality and consistency of responses At the end of the workshop, each participant will have their own agent-style system, capable of converting inputs into useful recommendations, along with a reusable framework to apply to real problems. This workshop is aimed at developers, data professionals, and curious people who want to move from using AI tools to designing intelligent systems. No prior AI experience is required, only basic Python knowledge and a desire to learn. More than a technical session, this workshop proposes a new way of understanding AI: not only as a tool that responds, but as a system we can design.
PyBlend: Towards an AI Food Scientist for Nutritional Product Design
Imagine having a “food scientist” built in Python who, instead of wearing a lab coat, uses DAGs, embeddings, and LLMs to help you design nutritious powder blends. In this talk I’ll present PyBlend, an AI agent that takes a nutritional brief in natural language (for example: “I want a vegan, high‑protein, low‑sugar blend that’s suitable for dehydration”) and turns it into a quantitative formulation ready for the lab: ingredients, raw and dehydrated proportions, nutritional profile, and estimated cost. We’ll walk step by step through how to combine intelligent ingredient search (starting from one‑hot encodings and tabular features, all the way to text and nutrition embeddings), hybrid retrieval over food databases, and LLM agents orchestrated in a directed acyclic graph. Everything is implemented in Python, built on open-source libraries, and designed to be reproducible and extensible for anyone who wants to push language models beyond the classic “chatbot” use case. If you’re interested in building Python agents that do real scientific/applied work, not just answer questions, if you work with tabular data, search, optimization, or simply want to see how an LLM can end up designing a functional food formulation, this talk is for you. You’ll leave with concrete ideas, architecture patterns, and code examples you can adapt to your own domains.
Dashboards That Think: Build Agentic Analytics with Sigma
Traditional dashboards only show data: you ask, they answer, and you start over. In this hands-on workshop we will take the next leap: we will build an agentic dashboard in Sigma that reasons about data, applies business logic, and executes actions, without writing code. Working on live data in the warehouse, you will learn step by step to: design a dashboard on Sigma's canvas; incorporate Sigma Agents to answer questions in natural language, chain multiple reasoning steps, and trigger workflows; and connect the dashboard with external tools and systems via MCP, all governed and without taking data out of your platform. In the end you will have an intelligent dashboard working end to end that you can replicate in your own work. It is an ideal session to understand, hands on keyboard, what "agentic analytics" really means in today's AI conversations, and how anyone can build it without being a data engineer or analyst
Beyond Vibe Coding: Spec Driven Development with Code Graphs
Artificial intelligence is changing the way we build software, but writing prompts and accepting code suggestions is not enough to work on real systems. In applications with multiple layers, dependencies, and business rules, the real challenge is not just generating code, but understanding where to change it, how it impacts the system, and how to validate it correctly. In this workshop you will explore an evolution of Spec Driven Development using Code Graphs as a structured context source. Starting from a web application built with FastAPI, you will work on a specific feature following a guided flow: requirement, specification, graph context, planning, tasks, implementation, and validation. During the session you will learn the Spec Driven Development flow, from defining the requirement to creating the specification, planning, generating tasks, implementation, and validation. You will also see how a code graph can represent files, functions, classes, relationships, and dependencies, allowing AI not to depend solely on textual context or isolated prompts. This will help you reduce common errors such as duplicating logic, modifying incorrect layers, or ignoring affected tests. Upon completion, you will understand how to move from improvised use of AI in development to a more structured, traceable, and reliable process. You will learn to combine specifications, real code context, and AI assistance to build software with greater technical clarity, better impact validation, and logic applicable to real projects.
Esneider Bravo Benitez
Software Engineer @ Muno Labs
Jonathan Vallejo Muñoz
Senior Director of Software Engineering @ Lendingfront
Stop mocking, start containerizing
“Write tests. Not too many. Mostly integration.” Kent C. Dods While unit tests have their place, integration tests validate how your systems behave under real-world conditions. Yet too often, developers fall back on mocks that simulate dependencies rather than testing with the actual services their code interacts with. In this workshop, we’ll explore a better approach: Testcontainers is a powerful Python library that enables you to run real Docker containers as part of your test suite. Whether you're testing against PostgreSQL, Redis, or HTTP APIs, you’ll learn how to spin up disposable, isolated environments that bring realism and confidence to your testing practice. Whether you're testing microservices, monolithic backends, or data pipelines, this workshop will show you how to build tests that don’t just pass but prove your system works. Bring your laptop and a running Docker engine, we’re going to get our hands dirty!
Use it or lose it! Token diet with TOON to fatten your wallet and help AI understand more
What if we told you that every time you send JSON to an LLM you are paying an invisible "tax"? In the Generative AI era tokens are the new gold, and with standard JSON (with its redundant braces and repeated keys) you are burning them. In this session we will review the history of data notation to understand why current tools are not optimized for LLMs and we will present TOON (Token-Oriented Object Notation), a notation that combines the best of two worlds: the readability of YAML and the density of CSV. But we will not only talk theory, we will also work with real data and see how TOON manages to reduce token consumption compared to JSON. We will also demonstrate something important: spending less does not mean understanding less! Because just by using TOON many benchmarks show improvements in their metrics. It is time to put your data on a diet!
