Talks

With policy support and innovative exploration of blockchain technology from both Eastern and Western countries, Solana aims to become a borderless, 24/7 internet capital market, fostering new opportunities for institutions and individual developers. The presentation will introduce the Solana Python SDK and ecosystem technical support. Now, everything on-chain development can be achieved with Python, including how individual developers can use Python to build applications, arbitrage bots, integrate AI with blockchain, and participate in open-source contributions. For institutional developers, the presentation will cover the technical implementation practices of using Python to build next-generation financial systems, real-world asset (RWA) on-chain, and stablecoin payments, among other scenarios.

As we stand at the forefront of the explosive development of artificial intelligence, Python has become the key bridge connecting creativity and the realization of intelligence. As a staunch supporter of the open-source field, AWS continuously empowers the developer community by contributing over 1000 open-source projects. The AWS Strands Agent SDK is precisely a continuation of this open-source commitment, making building AI Agents easier than ever before. I will take you from theory to practice, demonstrating how to build intelligent Agents with concise Python code, allowing every developer to unleash the potential for AI innovation under the guidance of the open-source spirit.

Elasticsearch is the world's leading search engine. Traditional keyword search cannot meet the needs of today's intelligent era. Contemporary enterprises propose semantic search, which is searching based on the semantics of text rather than simple keyword matching. Additionally, we need to search for other data types, such as images, voice, and video. Since version 8.0, Elasticsearch has provided vector search (dense vectors, sparse vectors). It can perfectly solve text semantic search and multimedia data search. However, vector search is not perfect, especially for text search. We can use hybrid search (keyword search, vector search) for multi-path recall and rank the final results. This method can improve search accuracy and recall rate. In today's AI development, combined with large models, we can integrate the search results with large models and use GenAI to obtain inference results. Since enterprise data or private data is generated every moment, and the knowledge of large models is limited to the time of model generation, and the data of large models is obtained through training on web data. Using large models to infer enterprise or private data without context often leads to hallucinations because this knowledge does not exist in the large model. By combining Elasticsearch's vector search technology to search enterprise data or private data and providing the search results as context to the large model, hallucinations can be eliminated. This technology is also known as RAG (Retrieval-Augmented Generation). This topic will provide a detailed introduction to Elasticsearch's vector search technology and how to use it for RAG application development and the latest agentic RAG.

In production environments, when Python deadlocks, `gdb -p $(pidof python)` is often the only lifeline that keeps things running. With PEP-768 “Remote Debugger” set to land in Python 3.14, many believe GDB for Python will become increasingly obsolete. This presentation will explore how GDB debug Python processes, its blind spots and pitfalls, how it inspired PEP-768, and the debugging capabilities that PEP-768 still cannot address—capabilities that only GDB can fill.

According to reports, Japanese ranks among the most difficult languages for native English speakers to learn (FSI Language Difficulty Level: https://www.fsi-language-courses.org/blog/fsi-language-difficulty/). There are many reasons for this, such as Japanese having three distinct writing systems—hiragana, katakana, and kanji—and words appearing without spaces between them. In this presentation, I will first outline the differences between Japanese and many European languages, then demonstrate how Python and natural language processing libraries can be leveraged to support Japanese language learning.

In modern semiconductor fabs, retrofitting existing equipment with data interfaces, real-time monitoring, and flexible control capabilities presents an increasingly pressing challenge. This session will share an automation framework designed around Python for the intelligent retrofitting of legacy equipment. The framework integrates device communication protocols such as SECS/GEM and MCProtocol, paired with AI vision recognition modules and data analysis workflows for predictive maintenance and process optimization. The overall architecture adopts a microservices design, utilizing Django for the backend and Vue.js for the frontend, enabling seamless integration with MES, FDC, or production line systems. Although still in development, the framework already meets practical manufacturing requirements, offering a viable solution for achieving smart manufacturing through open-source technologies.

Exploring packaging and distribution solutions for Python projects, along with environment management approaches. The Python ecosystem offers multiple tools and methods to address these two core challenges, and selecting the appropriate solution is crucial for a project's maintainability, portability, and reusability. This analysis examines the principles, usage, characteristics, and relative strengths and weaknesses of various tools.

Coding Agent is undoubtedly a red ocean market today. This session will primarily share how an individual developer built a programming assistant from scratch using Python, designed event-driven and Human-in-the-Loop workflows, and implemented multi-agent collaboration within event-driven workflows using both A2A and MCP protocols.

Blockchain, as a nascent technology, remains immature, and smart contract debugging tools don't always solve my problems. How can we achieve smooth dynamic debugging of EVM's underlying memory, stack, and bytecode? Popular tools like Foundry and Simbolik have significant limitations and don't offer the freedom we need. Kontrol, as a symbolic execution tool, is powerful but potentially overly cumbersome. Why not dig straight to the core and perform low-level debugging at the virtual machine reverse-engineering level? Let's reverse-engineer smart contract bytecode directly and transform Py-EVM into a low-level debugging powerhouse!

Networks are effective for representing relationships between entities across a range of disciplines, and network analysis techniques are widely used for understanding various types of complex networks, e.g., social networks, biological networks, transportation networks. Network analysis tasks, such as community detection, centrality analysis, and network visualization, play important roles in many disciplines. Existing network analysis tools, however, lack efficiency in analyzing massive network data or may not provide comprehensive analysis functions, which limits their practical applicability. We present EasyGraph, an open-source library that supports many network data formats and covers important functions like structural hole spanner detection and network embedding. Notably, we have optimized several key functions for enhanced efficiency. We believe that EasyGraph is a powerful tool for dealing with major analytical tasks in complex networks across various domains. EasyGraph has been downloaded for over 800 thousand times via PyPI.

From GraphRAG infrastructure software to small projects featured in Hacker News' top 5, relatively serious pop music releases, and logo/icon design—GenAI capabilities have enabled me to build numerous things with output efficiency previously unimaginable. This topic will share some of my thoughts and observations on “vibe-building,” along with subsequent experiences and ideas from self-hosting the construction of a Personal Memory/Context Manager.

Python for everything Python for data Python for run Python for fun Python for life Python for rust Python for llm Python for friends Python for here

In traditional approaches, animations are created using professional software, where elements and animations are edited directly within a graphical interface. However, with JAnim, I set out to build a framework for creating animations through programming. Inspired by Manim, this framework uses code to define both the objects in a scene and the animation process. Programmatic animation makes it easier to ensure reproducibility and consistency, and it is particularly well-suited for demonstrating algorithms that are inherently tied to programming—such as sorting algorithms—as well as for batch-generating animation content. In short, this programmatic approach enables JAnim to shine across diverse creative directions. On top of that, JAnim introduces many user-friendly features, such as a preview window for easy animation debugging that responds instantly to code changes, and an improved workflow for integrating audio and video—making it something of an “alternative editing tool.” In the end, while JAnim is code-based, its rich supporting features ensure the process feels smooth and accessible rather than cumbersome.

With the explosion of LLM applications, we've already seen many large model applications in different scenarios, but the forms of human-computer interaction still seem to be lacking: besides IDEs for coding tasks, most assistant applications still primarily rely on dialog boxes, and a few agent applications output rich text web pages or documents. This lecture will review the human-computer interaction modes of LLM applications and share my envisioned and attempted more organic interaction modes.

With the popularization of AI, feature engineering is becoming increasingly important in quantitative research. Its core encompasses multi-dimensional data cleaning, feature extraction and selection, construction and optimization, and other steps. This presentation will analyze how to extract key features from massive data through a logical framework analysis and practical case sharing (such as the LASSO attribution model in FOF fund investment), and combine AI and statistical modeling methods to achieve feature optimization, improve trading strategy performance, and provide a more efficient support path for quantitative research and intelligent investment.

With the emergence of large model technology, developers are beginning to use large models to develop their applications. However, in the actual development process, the vast majority of developers are more proficient in using text-based models for application development, and are not as skilled in using multi-modal large models to develop applications. In this sharing session, we will introduce some techniques and methods for developing applications based on multi-modal large models, providing explanations, usage instructions, cases, and tips for integrating common multi-modal large models. This will help developers understand the use of multi-modal large models, so they can utilize them in their own work scenarios.

Entering the Age of Agents: How to Rapidly Build Agentic Solutions? This course focuses on using Python with Semantic Kernel to orchestrate business flows for enterprise-level agents, and building applications using A2A and MCP.

The Python standard library contains two important Future classes—concurrent.futures.Future and asyncio.futures.Future—used to hold the asynchronous results of processes/threads and coroutines, respectively. In this talk, we'll begin by tracing the evolution of these two Future classes to clarify some common definitional questions: How do we distinguish between the twins of parallelism and concurrency? Why are concurrency and asynchronous operations always closely intertwined? Next, we'll deepen our understanding of Python's core asynchronous concept—“coroutines”—by exploring these questions: What are “stacked” and “stackless coroutines”? How are they implemented in Python? Why is “goto harmful”? What is the intrinsic connection between “structured programming” and the “structured concurrency” paradigm? Finally, we will explore the future potential and development direction of the Future module by examining upcoming Python features like “free threads” and “sub-interpreters.”

With the rise of AI agent applications, Python has become the preferred language for agent development. Browser-use capabilities, serving as the bridge connecting AI to the online world, unlock limitless possibilities for universal agents. This session will delve into developing a fully functional browser-use agent using Python. Combined with the PPIO Agent Sandbox product, we'll demonstrate practical solutions for running agents stably and cost-effectively within a secure, isolated cloud environment. This empowers developers to efficiently transform ideas into real-world applications.

I will demonstrate Solidigm and BF3 AI Lab's joint inference work based on the Solidigm Ignition stack, along with its integration with the Python ecosystem. CSAL Background CSAL (Cloud Storage Acceleration Layer) is a solution for big data and AI. It is an open-source user-space FTL, cache, and IO trace component designed to accelerate AI and big data storage systems within SPDK (merged into the mainline). Commercially, it powers Alibaba's cloud storage systems. For foundational details, refer to: https://www.solidigm.com/products/technology/cloud-storage-acceleration-layer-write-shaping-csal.html Paper co-authored by Alibaba and Solidigm at the premier computer science conference EuroSys2024: https://dl.acm.org/doi/pdf/10.1145/3627703.3629566 Plus the joint presentation and poster session by the BF3 team and Solidigm at GTC2025.

The implementation of artificial intelligence (AI) applications has become more widespread and common recently than ever before. However, during the acceptance process of recent AI projects, it is found that they face more difficulties than traditional application projects. This speech starts by discussing the cognitive differences in expectation management and the difficulties in the acceptance process of AI projects, and puts forward certain suggestions on the labeling, verification methods and acceptance criteria for different types of AI projects.

For large Python projects, maintaining architectural cleanliness poses significant challenges, primarily manifested in the difficulty of preserving simple and clear dependencies between modules. Complex dependencies lead to high architectural comprehension costs, blurred module responsibilities, and other issues that ultimately impact team development efficiency. This presentation will share insights on how to govern module dependencies in Python projects and maintain their cleanliness, covering both tools and techniques.

In the AI era, as models and applications rapidly evolve, the cost and performance of inference processes become increasingly critical, making end-to-end AI observability an essential component. As the most widely used programming language in the AI era, Python naturally requires a more comprehensive end-to-end observability solution. LoongSuite Python Agent is the latest AI data collector open-sourced by Alibaba Cloud's Observability Team. This presentation will share best practices for full-stack observability using LoongSuite Python Agent.

In this session, I'll start with fundamental AI applications and gradually expand to cover RAG applications, agent applications, multi-agent applications, and MCP—all of which you frequently encounter. We'll analyze whether AI Gateway truly delivers value based on real-world scenarios, and whether it can enhance the efficiency of Python-based AI applications.

In the context of the rapid development of open-source large models, how to quickly convert open-source large models such as Qwen, DeepSeek, and Llama into usable API services has become a key challenge faced by developers. Traditional deployment often needs to handle complex steps including containerization, infrastructure configuration, and inference engine optimization. This not only requires in-depth operation and maintenance knowledge, but also involves a large amount of manual configuration.

With the rapid adoption of large language model (LLM), we are witnessing an explosive growth in AI applications and agents. However, as probabilistic black-box systems, LLMs pose significant challenges for developers in terms of debugging, evaluation, and optimization. Their internal mechanisms are opaque, and outputs are often unpredictable and difficult to interpret. This talk will focus on the Python ecosystem and demonstrate how to build end-to-end observability for LLM applications using **Langfuse.**

Introducing sphinx-nekochan, a library for inserting cute nekochan(cat) emojis into your documents. This library is provided as an extension to the Python documentation tool, so you can easily create websites and slides with Nekochan emojis. These Nekochan emojis are created and distributed by Shikamatsu-san.

Today, GitHub Copilot supports mainstream IDEs including VS Code, JetBrains IDEs, Visual Studio, Eclipse, and Xcode. With capabilities like Agent Mode and MCP, it significantly enhances the Python development experience. Whether building projects from scratch (like rapidly generating Flask APIs or data processing scripts) or maintaining large codebases (through intelligent autocompletion, refactoring, and test generation), GitHub Copilot drastically reduces repetitive tasks, allowing developers to focus more on logic and innovation. This session will showcase real-world examples demonstrating how GitHub Copilot serves as the intelligent engine for Python developers.

This lightning talk will cover the latest progress on Python Enhancement Proposals (PEPs) within the Python packaging ecosystem. We'll briefly review key completed, accepted, and under-discussion proposals, including important features like inline script metadata (PEP 723), dependency group management (PEP 735), and a standardized lockfile format (PEP 751). These proposals are driving standardization in Python packaging tools, enhancing developer experience, and making dependency management more reliable and efficient. Ideal for developers interested in Python packaging tools, this session offers insights into the ecosystem's direction and upcoming new features.

With the explosion of LLM applications, we've already seen many large model applications in different scenarios, but the forms of human-computer interaction still seem to be lacking: besides IDEs for coding tasks, most assistant applications still primarily rely on dialog boxes, and a few agent applications output rich text web pages or documents. This lecture will review the human-computer interaction modes of LLM applications and share my envisioned and attempted more organic interaction modes.

There is a structural fault in the field of practical scientific computing: the research side faces reuse barriers due to the fragmentation of experimental scripts, while the engineering side is limited by the high maintenance cost of traditional imperative code and the complexity of integrating multiple toolchains. To systematically address this issue, the open-source project informatics innovatively introduces a functional programming paradigm in its underlying architecture design, achieving four technological breakthroughs: the design of pure function computing units with no side effects completely eliminates state management risks; the declarative pipeline architecture visualizes the assembly of computing units through Unix-like pipeline operators, significantly accelerating prototype verification and engineering implementation; the unified parameter management protocol uses an external configuration centralized injection mechanism to solve the complexity of parameter passing; strong type safety ensures interface data type verification during workflow instantiation, preemptively intercepting 70% of runtime errors.

Unlike English, Japanese doesn't use spaces to separate words. Furthermore, with complex word conjugations, beginners often spend a lot of time identifying the base form of words when reading extensively. Although morphological analyzers (like Sudachi) can automatically extract word base forms, they often encounter significant Out-of-Vocabulary (OOV) problems when processing colloquial texts such as subtitles, manga, and Galgames, which affects learning efficiency. This sharing session will not only introduce how to use Python to call Sudachi, but will also focus on how to solve this problem.

Ragflow is a widely recognized RAG application framework, yet its practical implementation faces numerous challenges. Building upon this foundation, Ragflow-plus extends its capabilities for academic domains through enhancements such as user management, image-text association, and document interaction, achieving a transformation from “general technical solutions” to “domain-specific solutions.” This session will share comprehensive practical experience covering the entire process of RAG application deployment: problem discovery, solution comparison, application development, and deployment implementation.

In the process of deploying large language models, Python serves as both an experimental tool and the primary engineering platform. This session will demonstrate how to rapidly implement enterprise AI applications by leveraging the Python ecosystem and open-source projects (RAGFlow, OpenWebUI, Dify). Through a real-world case study, we will showcase the architecture and practical experience of knowledge bases, agents, and MCP servers, while exploring Python's unique advantages in building scalable enterprise-grade AI systems.

Functionality-driven testing technology aims to empower automated traversal tools with the ability to perceive business functions by defining application functionality as “properties.” This enables automated inspection of functional errors and enhances coverage, thereby providing automated traversal techniques with more robust error detection capabilities.