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
STUART: An Autonomous Hacker Agent Built in Python
What if you give a Python agent an IP address and ask it to find the server's vulnerabilities on its own? That's exactly what I did. In this talk I present STUART, an autonomous pentesting agent I built with AG2 (AutoGen) and GPT-4. The agent can analyze target systems without human intervention, following the first stages of the Cyber Kill Chain: reconnaissance and vulnerability identification. The architecture is 100% Python: an AssistantAgent backed by GPT-4 that reasons and plans, and a UserProxyAgent with a Code Executor that interacts directly with the target system. All orchestrated by AG2, the open-source framework for building multi-agent systems. The talk includes a live demo where STUART will analyze a vulnerable system deployed in Docker. You'll see step by step how the agent scans ports, identifies services, detects vulnerabilities, and reports findings—all autonomously, deciding for itself what to do at each step. Agenda: Introduction: can an LLM find vulnerabilities on its own? (3 min) Cyber Kill Chain: the framework that guides the agent (5 min) STUART architecture: AG2, agents, and real code (7 min) Live demo: STUART analyzing a vulnerable system (8 min) Results, limitations, and next steps (5 min) Closing and Q&A (2 min) You'll take away practical knowledge on how to build agents that act in the real world with AG2, and a concrete perspective on what offensive AI can do today. If a Python agent can find your vulnerabilities, how should defense teams prepare? All demonstrations are performed in controlled, ethical environments.
Vulnerable AI Systems: Real Data, Responsible Design
29% of attacks bypass the security filters of the most widely used LLMs in production. It's not a bug. It's the nature of the system. LLMs are stochastic processes trained on human language—the most flexible, ambiguous, and manipulable medium that exists. That makes them incredibly powerful. And that's exactly why they're vulnerable. There's no patch for that. Only design. This talk presents the results of llm-break-bench: 3,360 adversarial tests on GPT-4o, Claude, Gemini, Grok, and DeepSeek using MLCommons AI Safety v0.5 and OWASP LLM Top 10 as standards. The numbers break intuitions. The smartest model in the benchmark is 5 times more vulnerable than the cheapest and 11 times more expensive. The most criticized by the press ends up second in security, and the reason behind that explains everything that's wrong with how the industry deploys AI today. The data is the starting point. The talk connects them to real use cases where LLMs are in production: RAGs, chatbots, agents, code assistants. It shows where design fails, what consequences it has (Air Canada paid for it), and how to build differently. The closing is actionable: 5 design pillars for AI systems that don't depend on the model for their own security, with real code from NVIDIA NeMo Guardrails and Meta LlamaFirewall. If you have an LLM in production or are about to, this talk changes how you design it.
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.
Not Every Nail Needs an AI Hammer: Architectures That Think Before They Generate
We live in an era where everything "needs generative AI"... or so we're told. In this talk I'll cut through the hype to talk about what really matters: designing clean, intentional, and sustainable architectures. We'll explore how to combine the best of the traditional world with emerging tools without falling into over-engineering. Because sometimes a well-placed regex beats a multi-million-parameter LLM. If you're tired of seeing Ferraris parked at the supermarket, this talk is for you.
The GenAI Revolution Reaches RecSys
When we talk about the generative AI revolution, the conversation usually stays close to chatbots, image generation, and code assistants. But the same architectures that powered that wave (transformers, autoregressive modeling, scaling laws) are quietly reshaping fields most people don't associate with GenAI at all. Recommender systems are one of the most interesting examples. Meta, Netflix, Google, Spotify and others are replacing decades-old recsys pipelines with transformer-based foundation models, and the results are hard to ignore. This talk is a practical tour of that shift from a Python engineer's seat.
Hacking AI Agents with Python
Artificial intelligence is evolving from static models to autonomous systems capable of reasoning, making decisions, and executing actions through tools and APIs. These systems, known as AI agents, are primarily built in Python. But with this evolution comes a new attack surface. In this talk we'll explore how AI agents can be exploited from an offensive perspective, using Python to demonstrate real attacks such as: - Prompt injection in agent pipelines - Information exfiltration through RAG - Decision manipulation through adversarial inputs - Abuse of connected tools and APIs From these scenarios, we'll show how to design security testing (pentesting) specific to AI systems, including black-box, gray-box, and white-box approaches. The talk won't focus only on attacks but also on how to mitigate them, presenting a practical roadmap to evaluate and strengthen AI systems in production. This session is aimed at Python developers, data scientists, and engineers building or integrating AI systems who want to understand how to secure what they're creating.
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
Structured Learning: An AI-powered platform that transforms academic papers into interactive learning experiences.
Structured Learning: The AI Platform That Other AI Agents Build" Subtitle: A real platform that converts academic papers into interactive learning modules, built as a solo developer with an agent pipeline that takes every GitHub issue to a merged PR, on pure Python, async FastAPI, and AWS What do you do when you need to understand and implement a research paper, and existing tools force you to jump between five tabs — PDF viewer, ChatGPT, IDE, notes, a search engine — and every jump breaks context? And what happens when, on the other side of the problem, you're a solo developer trying to build something serious to solve it, with AI agents that usually work well in demos but fall apart in production? This talk is the engineering story of Structured Learning: a platform that converts a research paper into a complete learning module — chapter-by-chapter explanations, incremental executable code, RAG chat, FSRS spaced-repetition flashcards, equation derivations, and a Neo4j knowledge graph connecting concepts across the user's entire library. Nineteen of forty-two features delivered as a solo developer. The product is the visible half. The interesting half is how it was built. The first topic is the product. Where a static tool promises "upload the PDF, get a summary," Structured Learning accompanies the three phases of working with a paper — researching it, understanding it, and applying it — across four custom AI agents in async FastAPI and LiteLLM, with multi-provider support across Anthropic, OpenAI, Google, DeepSeek, and Ollama. The second topic is engineering: an agentic development workflow pipeline that takes a GitHub issue to a merged PR — planning, implementation, tests, review, automatic patching, conflict resolution, documentation, and release. Each phase runs in an isolated git worktree with its own port range, so agents actually run in parallel without checkout contention. Commands in GitHub comments (/plan, /patch, /conflict) trigger background workflows that post phase-by-phase progress back to the same issue, creating a human-readable audit trail. Adaptive routing sends trivial classification to fast, cheap models, and heavy review or debugging to stronger models. PR creation is deferred until all quality gates are green — unit tests, end-to-end tests, and review. When review finds blockers, the pipeline automatically launches a patch workflow to fix them in place and re-runs verification. Real self-repair, no human in the loop for the common "almost right" case. The third topic is production: how this runs on AWS without breaking, and how we develop it locally without paying for cloud. The entire stack — S3 for PDF uploads and TTS audio cache, ECS Fargate for FastAPI backend and GROBID service, RDS PostgreSQL 16 with pgvector extension consolidating application DB and vectors, Secrets Manager for credentials, ECR with immutable image promotion — lives on Terraform with per-environment directory separation. The key to maintaining dev↔prod parity is LocalStack plus a single variable (S3_ENDPOINT_URL): the same boto3 client runs identically on both sides, no code branches, no mocks in tests. docker compose up reproduces the full AWS topology locally, enabling end-to-end flows — paper upload, audio generation, caching — without real credentials or cloud costs during development. You'll leave with a clear view of the product — a platform that covers the three phases of working with an academic paper. For research, it offers conversational search over arXiv and OpenAlex, and a Neo4j graph that detects shared concepts, knowledge gaps, and optimal reading order across your entire library. For explanation, it generates chapter breakdowns with key concepts and diagrams, step-by-step equation derivations that demystify the math, RAG chat and Socratic mode that answers with the paper's full context, and an annotatable PDF reader with "Ask AI" on any selection. And for practical application, it produces executable code that builds incrementally with dependency tracking, FSRS flashcards for measurable long-term retention, and comprehension quizzes that validate understanding chapter by chapter. And with three concrete engineering recipes to reproduce in your own stack. One for building serious AI products without magic frameworks: typed contracts with Pydantic, SSE streaming with cancellation, prompt caching, and per-task cost accounting. Another for scaling a solo developer to team velocity by applying agentic discipline to your own development cycle: isolated worktrees, resumable pipelines, auto-patching after failed review, GitHub as the agents' API. And a third for eliminating "works on my machine" from AWS infrastructure using LocalStack as a local S3 mirror. The thesis: agents don't replace engineers, they replace the glue between engineers and the boring 80% of the SDLC — and that's where compound returns live.
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.
Vision-Language-Action Models: From Chatbots to Interaction with the Physical World
LLM-powered chatbots marked a before and after in artificial intelligence, enabling systems capable of understanding and generating natural language with great fluency. More recently, multimodal models expanded these capabilities by incorporating images, audio, and video, bringing AI closer to a more complete understanding of its environment. In this talk we'll explore Vision-Language-Action Models (VLA), architectures that combine computer vision, natural language, and decision-making to let intelligent agents interpret their environment and execute actions in the physical world. We'll also see how the Python ecosystem has become a fundamental piece for developing these solutions through modern tools like PyTorch, Hugging Face, robotic simulators, and open source frameworks currently used in robotics and multimodal artificial intelligence.
Provenance by Default: AI Media Pipelines in Python
A model can now generate a video that looks indistinguishable from one your camera recorded. The same is true for an image, a voice, or a song. As Python developers, we are building those pipelines — and we are also the ones who will be asked, very soon, to prove what came out of them. This talk is about building generative media pipelines in Python in a way that answers that question by default. We'll walk through Genblaze, an open-source SDK (github.com/backblaze-labs/genblaze, MIT licensed) that I work on at Backblaze, and use it as a vehicle to talk about the design problems any team faces when wiring AI generation into a real product. We will cover, with live code: 1. The Pipeline pattern. A fluent Pipeline → Step → Run → Manifest API built on Pydantic v2 and Runnable[In, Out] ABCs. Sync, async, and streaming runners share a single mental model. We'll see how chain=True propagates assets, how input_from=[0, 1] enables fan-in for AV compositing with FFmpeg, and how fallback_models=[...] retries automatically when a provider drifts. 2. One API, eleven providers. OpenAI Sora, Google Veo, Runway, Luma, Decart, Replicate, ElevenLabs, Stability Audio, LMNT, GMICloud, NVIDIA NIM — all behind the same submit / poll / fetch_output lifecycle. We'll see how a thin provider ABC plus a runtime-extensible ModelRegistry lets you adopt a model the same week it's released, without waiting for a library update. 3. Provenance that survives the file. Every run produces a canonical, SHA-256-verified manifest (deterministic JSON, sorted keys, NFC unicode, normalized floats) that gets embedded into the media itself PNG iTXt, JPEG/WebP XMP, MP4 UUID box, MP3 ID3v2, WAV LIST/INFO. We'll extract and verify a manifest from a real .mp4. We'll talk about what the hash does prove (integrity) and what it doesn't (authentication), and why that distinction is the entire point. 4. Privacy and policy. EmbedPolicy lets pipelines redact prompts, strip parameters, or swap to pointer-mode sidecars. SSRF protection on webhook and asset transfers. Trust modes for adversarial verification. 5. Storage and replay. Durable B2 / S3-compatible URLs, content-addressable layouts, and a CLI (genblaze extract / verify / replay / index) that turns any manifest back into an executable pipeline. 6. Agent loops with lineage. AgentLoop composes a pipeline factory with an evaluator; every iteration is linked via parent_run_id, so refinement chains are first-class in provenance — not a side note in your logs. By the end, attendees will have a clear, opinionated reference for how to architect generative-AI features in Python so that "what did this system actually produce, and can I prove it?" is a one-line answer instead of a ticket.
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
Cost Optimization Strategies for GenAI with Python and AWS
Is it possible to scale Generative AI without project success compromising the organization's financial stability? This session will address how to transform the deployment of large language models (LLMs) through architecture design oriented toward operational efficiency. Instead of accepting high token consumption as an inevitable cost, we'll explore a sustainable cost model that lets you build intelligent, scalable applications without sacrificing profitability. Through a technical path centered on Python and AWS services, we'll analyze key strategies such as model arbitrage, where application logic dynamically decides which intelligence engine to use based on task complexity. We'll dive into how smart use of low-impact vector databases and semantic caching reuse prior knowledge, achieving significant infrastructure savings. Attendees will discover how implementing async flows and batch processing optimizes available resources. This talk is a practical guide for architects and developers looking to lead the transition from costly prototypes to production systems that are technically and economically viable.
Python in the Browser: Powered by WebAssembly
What if the browser could run Python as a first-class language? In this talk, I'll show how PyScript makes it possible to execute real Python directly in the browser, powered by WebAssembly. Through a series of exciting, live examples, you'll see Python manipulating the DOM, calling browser APIs, and building interactive experiences, all without a traditional JavaScript codebase. I will also show a couple of examples of how you can embed both JavaScript and Python on PyScript to make even more exciting tools. I will also discuss what WebAssembly is, why it exists, and how it enables languages like Python to run safely and efficiently on the web platform. Finally, I'll discuss when tools like PyScript make sense, and compare it with similar tools. Whether you're a Python developer curious about the frontend, an engineer interested in WebAssembly, or simply someone who enjoys seeing the boundaries of Python pushed, this talk will change how you think about what can run in a browser.
From Expert Judgment to Autonomous Optimization: Encoding Human Expertise into LLM Judges with DSPy
A single misread clause in a reinsurance contract can mean millions in liability. Our LLM pipeline could extract and summarize these documents, but how do you know the output is actually correct? String matching fails ("USD 5,000,000" vs "$5M" scores zero), human review at scale is unaffordable, and a single LLM-as-judge prompt gives inconsistent, uncalibrated scores. The real bottleneck was never generation; it was evaluation. This talk shows how we solved it in two steps, both built entirely in Python. First, we encoded expert evaluation at scale. We collected structured reviews from five domain experts across different insurance areas, then used DSPy to distill their judgments into a panel of calibrated LLM judges, each targeting a single quality dimension (factual accuracy, task alignment, faithfulness, technical depth, clarity), weighted to reflect what experts actually care about. On our validation set, the panel's per dimension scores stayed within 10% of expert consensus across every dimension, with the same relative shape close enough to trust as a fitness function, not just a diagnostic. Expert disagreement turned out to be our most powerful debugging tool: where reviewers diverged, our definitions were ambiguous; where they agreed, we had ground truth. Then we closed the loop. Using DSPy's MIPROv2 and GEPA optimizers, we wired the judge panel as a fitness function and let the system rewrite prompts autonomously. Regression guards prevent gaming across dimensions. Humans review only the final score delta and diff through a CI gate, and experts shifted from repetitive review to refining the evaluation rubric itself, which is something only they can do. The stack is Python-native: DSPy, MLflow, LiteLLM, Pydantic. Every code snippet is production code, not pseudocode. You will leave with a concrete recipe for encoding expert knowledge into automated LLM evaluation and self-improving optimization, applicable to any domain where "correct" is nuanced: legal review, medical summaries, code review, customer support, or your own pipeline.
Mateo Rios Querubin
Senior ML Engineer @ Provectus / Universidad EAFIT
Sebastián Gómez Ahumada
Middle ML Engineer @ Provectus
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.
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.
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
Python and Machine Learning for Sustainable Thermochemical Optimization
Chemical engineering still relies heavily on costly, slow experimental trials to evaluate operating conditions in thermochemical processes. This talk proposes a practical approach based on Python and machine learning to accelerate that process: building predictive models from physicochemical data that estimate key outcomes without testing every scenario in the lab. A complete flow oriented toward real applications will be shown, from data to decisions, with the goal of reducing analysis time, lowering experimental costs, and supporting process optimization with environmental impact.
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
From Typosquatting to Infrastructure Poisoning
In 2026, Python supply chain security has moved beyond misspelled package names to become an infrastructure battlefield. This talk analyzes the technical transition from simple Typosquatting attacks to sophisticated poisoning of CI/CD tools and runtime environments. We'll explore recent real cases such as the TeamPCP campaign and the Aqua Security Trivy compromise, analyzing persistence techniques through .pth files that enable malicious execution without an explicit import. Finally, we'll present the roadmap for modern defense: from Sigstore and PEP 740 to compliance with the Cyber Resilience Act (CRA).
Clean Code in the Era of LLMs: Do Good Practices Still Matter?
Instead, research from METR, CodeRabbit, and GitClear is converging on an uncomfortable truth: code duplication has quadrupled, copy-pasted code now exceeds moved code, bugs have risen 70%, and security issues have nearly tripled. AI didn't break our codebases. It amplified what was already broken. So what do we actually do about it? Do decades of hard-won engineering wisdom still apply when a model writes half the code, or do we need a new playbook entirely? Are clean code, SOLID, DDD, TDD, and the design patterns we've spent decades arguing about dead weight in the age of Claude Code and Copilot, or do they matter more than ever? This talk makes the case for the second answer. Your codebase is now a prompt: clean code leads to better AI suggestions, which make it easier to stay clean. Messy code leads to worse suggestions, which make it harder to recover. We'll walk through which practices now matter more (SOLID, DDD, TDD), which ones have quietly turned against you (hello, aggressive DRY and Abstract Factories), and how to collaborate with an LLM without becoming a rubber stamp for its output. You'll leave with a concrete framework, Adversarial Collaboration, that you can apply the next morning: generate, critique, refactor, verify. Not vibe coding. Not perfectionist prompting. Real engineering, just faster.
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.
Understanding Cognitive Complexity in Python
Modern Python makes it incredibly easy to write code quickly, but much harder to keep it understandable as projects grow. This talk explores cognitive complexity: a metric focused not on what code does, but on how difficult it is for humans to read, reason about, and maintain. Through real Python examples, we will analyze how nested conditionals, branching logic, async flows, exceptions, and growing business rules silently increase the mental load required to work with a codebase. We will also discuss why traditional metrics such as cyclomatic complexity often fail to reflect actual readability, and how cognitive complexity provides a more human-centered perspective on maintainability. The talk includes practical refactoring techniques, common anti-patterns found in production Python projects, and lessons learned while building complexipy, an open source cognitive complexity analyzer for Python written in Rust, designed to provide fast local feedback and CI integration.
Your AI Eval Is Lying To You
When you set temperature=0 and run your AI eval, you expect the same input to give the same output. It doesn't. Recent measurements on Qwen3-235B at temperature=0 produced 80 unique completions on a single prompt. So when your eval reports "92% pass rate," what does that actually mean? Is it 92% capable, 92% reliable, or 92% lucky on a small sample? This talk is about the gap between how the AI eval ecosystem talks about scores and what those scores can actually support. We walk through five specific tools that fix the gap, all anchored to published methods: 1. Pass@k versus pass^k: capability versus reliability, two different questions that one number obscures (Chen et al. 2021, OpenAI Codex paper). 2. Wilson confidence intervals with proper boundary handling, so your "92%" comes with an honest range (Brown et al. 2001). 3. Bayesian pass@k with Beta-Binomial conjugacy, when you want a posterior rather than a point estimate (Hariri et al., ICLR 2026). 4. Sequential drift detection with EWMA, CUSUM, and OLS, to catch eval regression while it's small instead of after a customer reports it (Lucas-Saccucci 1990, Page 1954, Montgomery 2012). 5. Family-wise error control via Benjamini-Hochberg, Benjamini-Yekutieli, and e-BH FDR procedures, for when you're running multiple correlated drift checks in parallel and don't want false alarms (Benjamini-Hochberg 1995, Wang-Ramdas 2022). Each method gets a short demo in pure Python with no framework dependency. The audience leaves with reference implementations they can paste into an existing pytest setup tonight. The talk also previews an open-core pytest plugin shipping in July 2026 that packages these methods into a single eval pipeline with SARIF reporting and a baseline-regression workflow. The talk shows the open primitives and the methodology that drives them. The production AI-eval ecosystem (LangSmith, Arize Phoenix, Evidently, DeepEval, Promptfoo, and others) mostly uses absolute thresholds and simple averages. None of the ten platforms I surveyed combine sequential testing with FDR control on bounded scoring scales. The framing here isn't competitive; it's a methodological gap every team shipping production AI evals will hit eventually.
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
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!
