PyCon Lithuania 2026 Schedule

The carbon market is set to reach 1T dollars by 2030, yet 84% of offsets fail to deliver real climate benefits. Verification still relies on sparse site visits and self-reported data. This poster shows a Python workflow that audits carbon projects using satellite imagery and ML, detecting over-crediting and leakage in REDD+ sites. With open data and open-source tools, anyone can compare claimed versus observed forest outcomes and verify what projects actually deliver.

Catch silent ML failures before they reach production! This session demonstrates lightweight, practical techniques to validate and monitor ML models across their lifecycle. Using tools like DeepChecks and Evidently AI, attendees will learn how to detect data drift, evaluate model quality, and ensure trust in their models with minimal effort.

Free-threaded Python aims to significantly improve performance, allowing multiple native threads to execute Python bytecode concurrently. In this talk, we will explore the current state of Python's free-threading initiative and assess its practical readiness for widespread adoption.

This talk introduces how Python and FastText can be used to detect low-resource African languages using the MasakhaNER dataset. We cover key preprocessing steps, evaluation methods, and challenges such as dialectal variation and sparse data. The session also compares FastText with African-focused NLP tools like AfroXLMR and Masakhane Models, offering clear guidance on when each tool works best.

Statisticians and machine learning specialists have a lot to learn from each other (even if they don't think so). This talk lightheartedly awards points to both classical statistics and machine learning, with an attempt not to offend anyone (but to annoy everyone). Topics include: Are confidence intervals worth it? What is bias, anyway? Can I just code it in Python?

What if you could watch an AI’s thought take shape? For years, LLMs have been impenetrable "black boxes," but we are finally beginning to find ways to see how the ghost in the machine actually works. This talk explores **mechanistic interpretability**, a subfield of AI that aims to understand the internal workings of neural networks. Mapping these internal "circuits" is not only just a philosophical curiosity - or duty: it is a high-stakes engineering necessity for safety, debugging, and trust.

In 2025, classic data tests via Python are not enough. During 25-30 minutes talk I will show how Python powers modern Data Quality: from real-time freshness checks to anomaly detection and orchestrator integration. No AI hype: starting with quick Data Quality overview and problem statement I will show practical code, architecture, and hands-on engineering for resilient pipelines from Data Engineer/Data Quality Engineer perspective.

Most teams iterate on prompts by eyeballing outputs and hoping for the best. This talk presents a different approach: connect your prompt to a measurable downstream outcome, build a test set, and let metrics drive improvements. I'll walk through a complete feedback loop - from prompt to retrieval metrics to automated error analysis to LLM-powered iteration - and show how this turns prompt engineering from guesswork into something you can actually measure and improve systematically.

Good documentation doesn’t happen by accident. But it also doesn’t have to be painful. This talk shows how Python developers can integrate documentation naturally into their daily work. We’ll look at docstrings, turn them into readable docs with reStructuredText and Sphinx, and learn how few organizational measures, docs-as-code practices, and automation can help—or get in the way …

Writing tests is an important part of every project. In this talk, I will show how to improve your tests using Pytest, Faker, and Hypothesis. We will start with Pytest, a simpler and more readable way to write tests. Then we’ll look at Faker, which helps create test data more easily. Finally, we’ll explore Hypothesis, a tool that generates random test cases to help find hidden bugs. You will leave this talk with clear examples and useful tips to write better tests in your projects using modern tools.

With more and more tools abstracting from a developer's workflows, understanding how git visualization tools help - not simply using it - is more important than ever. In this talk, we take a look at the history of git workflows, the basics of git, and the renaissance of understanding version control in a world gone mad for “vibe coding”.

2D static plots are great, but they are static. Data isn't - it changes. So we turn a plot into an animation. But we don't live in planes - we live in space. And we want to send a message, not just show an animation. This leads us to the 3D animated story! In this talk I will close the gap between abstract data and its physical reality. Through step-by-step examples using (Geo)Pandas, (I)Pydeck, PyVista, Blender etc., I will turn basic charts into 4D stories with custom models added to geospace.

We are told that modern data engineering requires expensive cloud warehouses and enterprise SaaS. This talk challenges that narrative. I will show how I built scoris.eu - aggregating business data from hundreds of sources across Lithuania, Latvia, Estonia, Finland, and the UK - as a solo developer. Using a purely open-source Python stack (dlt, dbt, Prefect) on cheap infrastructure, I will demonstrate that with the right architecture, you can integrate data at scale without burning cash on the cloud.

Even small changes in LLMs can impact output quality, safety, and user experience. In this talk, we’ll show how to log experiments with Langfuse, automate tests with Pytest, and enrich them using Hypothesis-generated random data scenarios. Participants will learn how to use code, tests, and data-driven A/B tests to improve LLM development.

LLMs can answer questions, but can they conduct research? Real research requires planning, data gathering, synthesis, and refinement. This talk explores Python patterns for orchestrating multi-step workflow to create autonomous research agents. We'll deconstruct the agentic architecture, from DAG-based planning to reflection loops, and show how to implement these concepts using practical Python patterns.

At some point, every Python developer hits a library that no longer fits. The docs end, the abstraction leaks, and you’re stuck between “best practices” and shipping. This talk starts with a mistake: modifying a library’s source code and proudly posting about it. It worked - and it taught me a better way. This isn’t a tool talk. It’s about mindset. Libraries aren’t sacred. They’re code. Code you can read, understand, and extend. And learning to look inside is a skill, not a sin.

One of the core fundamental pieces of technology every software-related tech stack is heavily dependent on is Git. The ability to version code and control the flow of development is the only common focus for every software project. We take for granted that everyone in the working industry can indeed properly version code. In this talk, we’ll explore the meaning of data versioning and how we could borrow methodologies from the software engineering field to better manage our data.

Have you ever happened to use GPS and realised that it is not working properly? The Sun could be responsible. We'll see a **real-world forecasting system** designed to predict a Space Weather phenomenon affecting GNSS accuracy and radio communications. The system is based on **CatBoost** and integrates space- and ground-based data. The talk focuses on **model design and evaluation choices**, showing how interpretability and uncertainty-aware forecasting can be combined in a real-time operational pipeline.

Python struggles with heavy data loads. Rust offers speed, and PyO3 makes bridging the two seamless. This talk shows how to build a shared Rust core to avoid code duplication. I will also cover using Apache Arrow for zero-copy data sharing and removing serialization costs entirely. Discover how this stack enables high-performance data processing in Python and Pyspark

In this talk, I propose to discuss the problem of building explainable AI with the two approaches - causal vs correlational. I will talk about what mech interp in LLMs. As a way to understand how models answer questions by looking inside them and checking which neurons activate when. I will discuss Anthropic's open sourced a python module - circuit-tracer, the Neuronpedia portal , will also talk about my own work with "activation cube" data structure (this is not a standard - I came up with it)

You use Python for your code why not use it to deploy code to the cloud too? Pulumi, an open source Infrastructure as Code library allows you to configure your cloud infrastructure using Python. In this session we'll deploy a data processing pipeline using Pulumi in GCP and talk through core concepts and fundamentals. Using this example we'll talk through practical best practice ensuring reliable and maintainable infrastructure that scales with your projects.

Python enables data professionals to move beyond analysis and transform information into clear, compelling stories. With various libraries, Python supports insightful exploration, expressive visualizations, and interactive elements that enhance communication. This talk highlights practical techniques for turning patterns, trends, and insights into engaging narratives, making data more understandable, impactful, and actionable.

AI systems are not neutral; they encode values that are opaque and separate from people. As developers, we are making decisions that shape who has power, who is surveilled, who is replaced, and who gets a voice, often without intending to. This talk frames AI ethics as a software engineering problem, not just a philosophical one. We’ll examine how everyday technical choices can unintentionally reinforce authoritarian tendencies around disinformation, manipulation, and harmful automated decision making.

Retrieval pipelines can improve from user feedback-but connecting signals like likes, dwell time, and clicks back to model retraining is tricky. This talk walks through an architecture for doing it: hybrid candidate generation (BM25 + embeddings), neural reranking, feedback collection, building evaluation sets, and the retraining loop. Concrete examples from production, with trade-offs between different approaches.

I'll discuss building capabilities on top of on-device language models, with Rewrite as a case study – a publicly available paraphrasing skill that is widely used across Microsoft's products. I'll cover comprehensive data collection strategies, carefully designed adapters training and evaluation. I'll discuss the engineering challenges we faced: achieving target latency while maintaining quality, hardening the system against edge cases, and how to deliver the technology to partners and the lessons learnt.

Airflow basics are well documented. Production Airflow is not. This talk covers the patterns, costs, and migration pitfalls that only show up after you've deployed: dynamic DAGs that scale, sensors that don't waste resources, CloudWatch bills that surprise you, and MWAA version upgrades that break in ways the changelog didn't mention. Practical lessons for teams running Airflow beyond the tutorial stage.

The web isn’t an API, but Python developers often treat it like one. This talk explores how to design Python interfaces for unstable data sources, focusing on schema evolution, defensive parsing, and protecting downstream users.

How can we **quantify uncertainty in time series** forecasts, without unrealistic assumptions, and with rock-solid guarantees? This talk introduces **Conformal Prediction** (CP), a framework to generate prediction intervals with guaranteed coverage. Whether you're forecasting energy demand, markets volatility, or space weather disturbances, CP helps you move **from point forecasts to reliable intervals** — even in non-stationary settings.

Transitioning from data science to software engineering doesn’t mean starting over, it means translating the scientific method into systems work. In this talk I would share the DS habits that most improved my engineering. I would also cover the gaps that surprised me and the concrete techniques that helped me close them. The talk would include useful tools related to hpc, multi-agent systems that help improve the code and runtime.

This talk is for anyone curious about what it’s like to run FastAPI in production. An asynchronous web framework with automatically generated documentation and dependency injection, FastAPI has made huge gains in popularity and overtook Flask in the 2025 Stack Overflow Annual Developer Survey. FastAPI’s features are impressive and picking it up is easy, but beyond that what is it really like to run in production? What joys and pitfalls await those deploying the most popular Python web framework?

Context Engineering is the new prompt engineering. As agentic workflows grow, just appending messages to a list causes context poisoning and latency spikes. In this talk, we'll look at a better architecture using the `deepagents` library. We'll explore the four pillars of context engineering: Write, Select, Compress, and Isolate. You'll learn how to treat context as a finite resource and build autonomous agents that can solve complex tasks without crashing your context window.

Explore how Apache Airflow modernized its massive monorepo by transitioning from complex custom scripts to official Python packaging standards and tools like uv. This session breaks down the management of 120+ distributions, the implementation of modular pre-commit hooks, and a novel approach to "static" shared libraries within a single repository. Join us to see a real-world blueprint for large-scale modularity as we advocate for the formalization of a Python workspace standard.

The module `itertools` provides 20 tools. There's 19 iterables and then there's `tee`... But what does `tee` do and why is it the only thing in the module `itertools` that's not an iterable? In this talk you will understand what `tee` does and when to use it, but most importantly, you will understand the paradox behind `tee`... See, the thing is that `tee` seems to go against the laws of iterators...

How do you turn thousands of PDFs into actionable insights? This talk shows how we built a Python-based AI assistant using LLMs and RAG to automate literature reviews: covering architecture, trade-offs, and real lessons from production use in policy research.

We at One Codex work in the microbiology field. This means that we deal with massive taxonomy trees all the time. It is impossible to cover everything, so in this talk, I am going to focus on the best data structure to: - store tree data - serialize it - display it on the frontend

In this session, we explore Specification-Driven Development (SDD) and its implementation in the Kiro IDE. You will see how machine-readable specifications drive the entire lifecycle—from EARS-based requirements to automatically generated code, tests, and documentation. The session also highlights the industry shift from developers as coders to developers as orchestrators of AI agents, defining intent and architecture while AI executes and validates the implementation.

SQL is an excellent DSL for relational data, but ORMs hide it behind their own leaky abstractions. This talk shows how to build a cleaner persistence layer and use Postgres to its fullest, without the overhead you never asked for.

When your embedding-based classification model fails, should you collect more data or try a different approach? This talk shares a practical XAI workflow using UMAP visualization and prototype analysis to uncover systematic failures. We will explore how to use these tools to identify semantic overlaps and make evidence-based decisions when debugging high-dimensional similarity systems.

Let’s make your functions smarter with decorators, simplify operations using lambdas, save memory with generators, and handle resources like a pro with context managers. We’ll mix clear explanations with hands-on practice - so you can write code that’s cleaner, faster, and feels Pythonic.

**I haven't written a single line of code in over a year.** As CTO of an AI startup, I've fully embraced vibe coding: orchestrating AI to generate production-ready code. 🔍 **Highlights** 1. **The paradigm shift:** from autocompletion to full project generation 2. **My 3-step workflow:** voice prompts, deep research, code generation 3. **The judgment trap:** why expertise matters more than ever You'll leave with practical techniques to ship 10x faster!

In the last few years, we’ve seen amazing progress around Python packaging for library code. Packaging applications usually requires more work, but thanks to recent developments it’s getting easier than ever. Will this be the year of packaging your Python app for the Linux Desktop?

As AI agents evolve from simple chatbots to complex multi-agent systems utilizing Model Context Protocol (MCP), manual validation becomes impossible. During this talk, I will demonstrate the process of architecting a quality assurance loop for these solutions. No theoretical fluff: I will focus on the practical analysis of automated pipeline results, interpreting Langfuse reports for cost and performance, and ensuring reliability from an AI Architect/System Engineer perspective.

The tools and workflows we use as developers are often as important as the code we write. The beauty of the Python ecosystem is that there are many options to the types of linters, formatters, type checkers, testing frameworks, and security scanners we can choose. However, too many options can paralyze decision making and often we use sub-optimal tools just because we've used them before. Learn some lessons from the tooling we use for maintaining, testing, and deploying our Python code at Mozilla.

Retrieval-Augmented Generation (RAG) often produces incorrect results when relying solely on vector-based similarity. While vector search is strong, it fails on exact keywords, acronyms, and domain-specific terms. This talk shows how to build high-accuracy RAG pipelines with Hybrid Search and Re-ranking using LangChain, combining vector and full-text retrieval and applying cross-encoder scoring to deliver more relevant context and reduce hallucinations.

Modern digital lending demands instant decisions, and behind those decisions is a Data Science workflow powered by scorecard. This talk explains how scorecards calculates credit risk in a transparent and scalable way, from feature engineering to production deployment. Using real examples from our company, models that enable fast, reliable loan approvals.