Discover the Talks at PyCon Colombia 2026 ✨
Browse every accepted session—titles, tracks, levels, and speakers—before you plan your days in Medellín.
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
Machine Learning Applied to Genetic Sequences
DNA contains massive amounts of biological information, but how can artificial intelligence help us understand it? In this talk, we will explore how Python and Machine Learning can be used to analyze genetic sequences in a practical and beginner-friendly way. Using public biological datasets, we will demonstrate how DNA sequences can be transformed into data suitable for machine learning models, covering concepts such as feature extraction, sequence representation, and basic classification techniques. We will also review popular Python tools used in bioinformatics, including Biopython, pandas, and scikit-learn, while discussing real-world challenges when working with biological data, such as high dimensionality, noise, and interpretability limitations. By the end of the talk, attendees will have a clear understanding of how to start building genetic analysis projects using accessible tools from the Python ecosystem, even without prior bioinformatics experience.
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.
From Voice to Action: Building an AI Assistant with Python and Google Workspace
Jumping between Gmail, Calendar, Drive, and Jira tabs for repetitive tasks is exhausting. That's why we built Attento, an assistant that lets you execute real actions in Google Workspace using natural language. In this talk we build Attento, an end-to-end voice assistant that turns natural language into real actions across Google Workspace. We'll cover architecture with FastAPI, OAuth 2.0 authentication with PKCE, function calling with Gemini, streaming with NDJSON, best practices with uv and Pydantic Settings, and the path from demo to production with Postgres and automated morning briefings.
Juan Manuel Marín Bedoya
Senior Data Engineer @ Huge
Juliana Suárez Ávila
Data Scientist @ Cuesta Partners
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.
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
Employability in the Age of AI
Artificial intelligence is changing the job market faster than ever. Many developers wonder: will AI replace me or empower me? In this talk I'll share my real experience going from being a developer in Latin America to working for companies in the United States—facing interviews, optimizing my professional profile, and adapting to an environment where AI is already part of daily life. We'll explore how AI doesn't replace the developer but redefines the value we bring: from writing code to solving real problems, communicating ideas, and building complete solutions. The talk will cover the future of programming, how to shift your mindset toward AI, which skills really matter today, how to stand out in international hiring processes, the role of AI tools in your professional growth, and common mistakes that hold back your employability.
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.
Feeding the Invisible: Food Security in Intermediate Cities with Python
In many countries, food insecurity is not only a social problem but also a data problem. In Colombia, key monitoring systems have lost continuity, leaving critical information gaps for public decision-making. This talk presents the development of a Python prototype to build a monitoring and prediction system for food insecurity risk in intermediate cities, using only open data. From a reproducible pipeline, multiple data science components are integrated: ingestion and processing of food price data (SIPSA), time series models for price forecasting (including classical approaches and machine learning like XGBoost), household segmentation through clustering from socioeconomic surveys, construction of a composite index relating income, prices, and vulnerability, and development of a decision support system (DSS) prototype. Attendees will take away a replicable approach for building complex indicators, strategies for working with imperfect open data, ideas for integrating models, socioeconomic data, and visualization in a single system, and a real example of applying Python in public policy and territorial development.
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
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.
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
Building a Transformer with Rust
Transformers are often perceived as incomprehensible giants. This talk aims to prove the opposite: they are not black boxes but elegant mechanisms that can be understood and mastered from their fundamentals. We present Molinete AI, a GPT-2-style model built strictly from scratch in Rust. No deep learning frameworks—just tensors, math, and full control. Inspired by Feste from Tag1 Consulting (trained on Shakespeare), this project poses a different challenge: training the network on Miguel de Cervantes's work to generate text in the style of the Golden Age. Throughout the session we'll break the model down piece by piece. With the support of a Manim animated presentation (over 4,000 lines of code), we'll make visible how information flows inside the network. We'll start from tokenization (BPE) and building basic operations, then dive into the core of the model: embeddings, causal mask, and Multi-Head Self-Attention. Finally, we'll explore the learning process, watching how gradients flow through the network during training. More than a demo, this talk aims to provide a clear, operational view of Transformers, connecting theory with a real from-scratch implementation.
NLP Without Labels: How to Cluster N Legal Processes of the Colombian State and Turn Chaos into a Production Classifier
What do you do when you have 600,000 legal complaints, zero labeled data, and a government entity waiting for results? This talk walks through the full process of building an unsupervised NLP classification system for the Procuraduría General de la Nación. Starting from raw administrative text—noisy, full of abbreviations and institutional jargon—I'll show how TF-IDF, truncated SVD, and KMeans combined to organize more than half a million records into 64 semantically coherent groups, without a single manual label. But clustering is only the starting point. I'll cover how clusters were validated, how a Logistic Regression classifier was trained on them to make the system deployable, and how the final pipeline was packaged in a .pkl that non-technical colleagues use in production today. Along the way we'll face real problems: elbow curves that don't behave, 1:20 size imbalances between clusters, and the tension between mathematical elegance and institutional usability. Because in the public sector, a model nobody uses isn't a model—it's a PDF gathering dust.
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.
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.
Elevate your code quality in Python with modern, ultra-fast tooling
AI coding assistants have changed how we build software. We can now generate features, refactors, and entire services in minutes — but speed without strong engineering practices quickly becomes technical debt. In this talk, I'll show how modern Python teams can build fast and reliable development workflows using tools like Astral's Ruff, Ty, and uv. We'll explore how traditional slow and noisy quality pipelines are being replaced by a new generation of tooling that provides near-instant feedback while improving code quality and developer experience. Topics include: Why AI-generated code makes automated quality gates more important than ever Using Ruff for formatting, linting, and fast feedback loops Using Ty for modern static typing and safer large-scale development Structuring formatter → linter → type-checker workflows Pre-commit hooks and CI pipelines developers actually enjoy using Reducing friction between local development and CI/CD The session is practical, opinionated, and based on real-world engineering experience building production systems with AI-assisted workflows. Whether you are a backend engineer, tech lead, or AI-native developer, this talk will give you a modern blueprint for building Python systems that move fast without sacrificing quality.
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
Real-Time Voice Systems: Design and Architecture in 5 Levels
Voice systems have advanced rapidly in recent years, but most implementations still stop at demos: simple combinations of Speech-to-Text, language models, and Text-to-Speech that work in controlled environments but fail when facing real-world conditions. This talk proposes a different approach: understanding voice systems as an architecture that evolves through maturity levels, from basic prototypes to real-time production-ready systems. Through a 5-level framework, we'll walk the full path of a Conversational AI system: from integrating basic components, through orchestration challenges (streaming, latency, turn-taking), to less obvious but critical problems like audio quality, robustness, and user experience, reaching real-time architectures with technologies like LiveKit, and finally exploring where the future is headed with end-to-end systems and multimodal agents. The talk is based on real experience building voice systems in production and focuses on engineering decisions more than specific tools. Attendees will leave with a clear understanding of how to design modern voice systems with Python, what problems to anticipate, and how to structure their own architectures to build world-class conversational experiences.
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
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.
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.
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.
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.
Lessons Learned Reporting Vulnerabilities in the Python Ecosystem
You've surely received that notification telling you to update a dependency due to a security flaw. But have you wondered what happens from when someone discovers that vulnerability until the patch reaches your project? In this talk I'll share my experience reporting vulnerabilities in the Python ecosystem. We'll explore the behind the scenes: from the technical finding and reporting process to collaboration with maintainers and patch publication. We'll address not only technical aspects but also the human factor—both crucial for effective vulnerability resolution. The challenges maintainers and the community face, especially in this new era of open source software security where artificial intelligence plays an increasingly relevant role.
Camila Plejia, Virtual Assistant Applied to People with Tetraplegia
The combination of different tools and technologies in artificial intelligence—Computer Vision, OCR, NLP, RPA, Voice to text, text to voice—gives rise to a virtual assistant, Camila Plejia, that helps people with tetraplegia, facilitating their daily tasks such as reading news, checking the weather, reviewing, reading and writing email, reviewing, sending and reading WhatsApp messages, searching for and watching a specific video on YouTube, among others. It allows a person with tetraplegia to have a window of communication with the outside world, considering they spend much time isolated between four walls and depend on a third party's assistance to perform activities.
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
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!
