Our Schedule

Week 1 - LLMS

Available to Start learning Now

This track will cover the latest topics, tools, and advancements in Large language Models (LLMs). This track delves into the transformative power of using LLMs with real-time data retrieval, enhancing the accuracy and relevance of AI-generated responses. Engage in our hands-on workshops demonstrating the latest LLMs techniques and their applications. Hear and learn from leading experts and LLM practitioners on how to make these systems more reliable and effective.

Week 2 - RAG

Available to Start learning Now

Ready to take your Retrieval Augmented Generation (RAG) implementation to the next level? These hands-on workshops dive deep into the architecture, tools, and strategies needed to scale your RAG systems without compromising on performance or maintainability.

January 23rd, 1:05 PM - 3:05 PM EST
‍
Workshop
Speaker - Stefan Webb - Developer Advocate at Zilliz
‍
Retrieval-augmented generation (RAG) has become increasingly popular in the latest wave of Generative AI applications, from sophisticated question-answering systems to advanced semantic search engines. This has led to an bewildering explosion of RAG methodology and research. How should we design optimal RAG systems given the breadth of design choices available?

In this workshop, we demonstrate how to quantify the performance of retrieval and generation in your RAG system using only open-source tools such as LangChain, HuggingFace, Milvus and RAGAS. Attendees will learn how to implement a complete RAG evaluation pipeline to explore design choices in a principled way, and leave with practical code examples and best practices that can be applied in real-world scenarios.

We finish with a summary of recent research in RAG evaluation, explaining improvements in RAG benchmarks, fine-tuned judge models, and methodology that extends LLM-as-a-Judge. Participants will leave not only well equipped with the skills to build optimal RAG systems today but be early adopters of cutting edge methodology and build pipelines that will stay relevant in the rapidly developing field of Generative AI.

Session Outline:

Module 1: Why is RAG evaluation important and how is it done? (30 minutes)In the first module, we’ll discuss why RAG evaluation is necessary to building a state-of-the-art application and some challenges in doing so. We will introduce the LLM-as-a-Judge method and explain how

Module 2: Let’s Build a Basic RAG with Milvus and LangChain. (30 minutes)In the second module, participants will build a basic RAG pipeline using only open-source frameworks - Milvus, LangChain, and the HuggingFace libraries, models, and datasets - with a Jupyter notebook. This provides the foundation for testing and evaluating RAG design choices.

Module 3: RAGAS and RAG Evaluation (45 minutes)In this module, we demonstrate how to use the RAGAS library to calculate performance metrics on both retrieval and generation and show how to use them to make design decisions. We frame the discussion using actual RAG methods that are used in production.

Module 4: Future Directions in RAG Evaluation (15 minutes)In this module, we briefly summarize some of the latest research in RAG evaluation, including methodology that builds upon LLM-as-a-Judge. Attendees will leave with a sense of how RAG evaluation may differ in 12 months.

By the end of this session, participants will be able to:- Set up and configure LangChain and Milvus for RAG evaluation workflows- Implement both task-based and introspection-based evaluation strategies- Use RAGAS to assess context relevance, answer faithfulness, and retrieval quality- Deploy LLM-as-Judge effectively while mitigating common biases- Apply industry-standard metrics for measuring RAG performance in production.

Background Knowledge:

- Basic understanding of vector databases and embeddings
- Basic understanding of LLMs and RAG architectures
- Intermediate Python programming skills
- GitHub account for accessing course materials

Required Libraries and Tools:Most recent versions:
- Python environment such as Miniconda (https://docs.anaconda.com/miniconda/)
- (Recommended) Visual Studio Code (https://code.visualstudio.com/)
- PyTorch (https://pytorch.org/)
- HuggingFace libraries (pip install -U transformers sentence-transformers hub datasets gradio)
https://huggingface.co/docs-
- RAGAS (pip install -U ragas)
https://docs.ragas.io/en/stable/
- LangChain (pip install -U langchain)
https://www.langchain.com/
- PyMilvus (pip install -U pymilvus) https://milvus.io/docs

January 23rd, 3:10 PM - 5:10 PM EST
‍
Tutorial
Speaker - Cameron Pfiffer - Developer Relations Engineer at .txt
‍
Extracting structured data from unstructured text can be challenging. This workshop shows how to combine RAG with structured generation to turn messy review text into clean, structured data that can be queried and analyzed systematically.

We'll build a pipeline to answer natural-language queries like "What do users say about battery life?" or "What are common complaints?" We'll first apply semantic search methods to locate relevant reviews, then apply structured generation to reliably extract structured data points like review categories, reported issues, and sentiment. We'll demonstrate how structured generation achieves this reliability by constraining LLM outputs to exact schemas with the Outlines library. You'll also learn how to extract multiple data points in a single LLM call for reliable and cost-effective analysis.

We'll walk through
- Building tools to find relevant reviews using vector embeddings and semantic search
- Implementing structured generation with Outlines to extract specific data points
- Applying structured data analysis problems

The goal of the course is to demonstrate how to turn unstructured data into reliable, structured data that you can actually use. We'll provide example code and schemas that you can adapt for your own projects. Basic Python and LLM experience recommended, but not required.
‍
Session Outline:

Module 1: Foundations of Structured Generation
‍
Learn how to make language models produce reliable, structured data using the Outlines library. We'll motivate this module by demonstrating some common failure modes when working with LLMs, and how to address them with open-source tools.

Module 2: Building RAG Systems with Structured Outputs
‍
In this module, we will demonstrate how to efficiently search for relevant documents and produce structured output from unstructured text. At the end of this module, you will have a simple structured data + RAG system to play with.

Module 3: Working with Structured Results
Finally, we provide a simple demonstration of how to analyze structured results -- what can you do with structured data? How can we build a quantitative understanding of our unstructured data? Expect to run some simple statistical analyses and visualizations.

All lessons include hands-on practice with real datasets, complete Jupyter notebooks, and example code you can adapt for your own projects. Python experience recommended.

Learning Objectives:

After this workshop, you will be able to:
- Understand the basics of structured generation, RAG, and simple data analysis.
- Optimize structured generation calls through prompting and structure design.
- Create a simple system to answer natural-language queries about unstructured data.

Tools:
- Python
- Outlines (structured generation library)
- A vector database like Milvus or ChromaDB
- Pandas (for data manipulation)
- Jupyter Notebooks
- Example datasets and starter code (provided via GitHub)

Background Knowledge:

We recommend some familiarity with:
- Python
- Basic Jupyter notebook use
- Basic understanding of data analysis and/or visualization
Everything else will be introduced during the course.

Week 3 - AI Agents

Live on Wed Jan 29 - Thu Jan 30

At the ODSC AI Agents track attendees will gain comprehensive insights into the latest advancements in Agentic AI techniques. They will learn about the architecture and deployment of AI agents, explore real-world applications, and understand how these agents can drive efficiency and innovation in various sectors. Sessions will cover practical implementation strategies, best practices for integrating AI agents into existing systems, and emerging trends in the field. Participants will leave equipped with the knowledge and tools to leverage AI agents to solve complex problems.

Week 4 - AI Builder's Toolkit

Live on Wed Feb 5 - Thu Feb 6

These workshop are all about bringing awesome AI application to life—rapidly build AI-driven solutions like chatbots, AI agents, and RAG systems in real time. It’s not just about learning tools; it’s about applying them to solve problems, create value, and explore what’s possible in AI today. Whether you’re an experienced practitioner or new to AI, this session is designed to inspire creativity and empower you to build.

February 5th, 3:05 PM - 4:05 PM EST
‍
Workshop
Speaker - Tony Kipkemboi - Founding Senior Developer Advocate at CrewAI

Autonomous AI agents are revolutionizing many industries, yet building effective multi-agent systems remains challenging. In this hands-on workshop, you'll learn to create and orchestrate AI agents by building a system that converts research papers into engaging podcasts using the CrewAI open source framework. We'll demonstrate how multiple specialized agents can work together to analyze academic content, generate natural dialogue, and produce audio output.

Working with real tools and APIs in Google Colab, you'll learn to define agent roles, implement task delegation patterns, and manage complex workflows. The workshop covers the entire pipeline from agent creation to system orchestration, with live coding examples you can build alongside me.

By the end, you'll understand the practical patterns for creating autonomous AI agent systems and be able to apply these techniques to your own projects.

The session's primary objective is to provide practical implementation experience with agent-based architectures. Attendees will learn to design agent roles, implement task delegation patterns, and manage complex workflows - skills directly applicable to their professional projects. By working through our paper-to-podcast pipeline, participants will understand how to break down complex tasks into manageable components and orchestrate multiple agents effectively.

Whether you're building content automation systems, optimizing business processes, or developing AI applications, you'll gain immediately applicable skills for creating robust agent-based solutions. We'll also have a Q&A session after each module, so feel free to ask questions.

Session Outline:
Module 1: Understanding AI Agents & ArchitectureLearn the fundamentals of autonomous agents, their roles, and how they communicate in multi-agent systems. Using our paper-to-podcast example, understand how to break down complex tasks into agent-based workflows.

Module 2: Environment & Tool SetupSet up our development environment in Google Colab and configure essential integrations including OpenAI and ElevenLabs APIs. Learn best practices for managing external service connections in agent systems.

Module 3: Building Specialized AgentsCreate agents with specific roles for research analysis, content generation, and audio production. Understand how to design agent capabilities and implement effective task delegation patterns.

Module 4: Implementing Agent CommunicationLearn how agents share information and coordinate tasks. Set up the workflow between research analysis, script generation, and audio production agents.

Module 5: Running the Complete Agentic SystemPut everything together to create a working paper-to-podcast crew. Test the system with real research papers and understand how to adapt this pattern for other applications. Close with Q&A and discussion.

Attendees will learn:
- How to design and implement multi-agent AI systems using CrewAI
- Patterns for breaking down complex tasks into agent workflows
- Integration of external services in agent systems
- Best practices for agent communication and task delegation

Tools used:
- Google Colab (https://colab.research.google.com/)
- Python programming language
- CrewAI framework (https://www.crewai.com/open-source)
- OpenAI API (https://platform.openai.com)
- ElevenLabs API (https://elevenlabs.io)
- Serper API (https://serper.dev/)

Note: Feel free to bring your preferred LLM provider API key to the session. Some of the providers offer free API keys you can use by creating an account.
‍
- Groq (https://console.groq.com/keys)
- Cerebras (https://cloud.cerebras.ai/)
- Sambanova (https://cloud.sambanova.ai/)

Background Knowledge:

- Basic Python programming experience
- Familiarity with Jupyter notebooks/Google Colab
- Understanding of basic AI/ML concepts
- Required API keys: OpenAI API, ElevenLabs API, Anthropic API, Serper API

All code will be provided in a Google Colab notebook that attendees can run during the session.

February 6th, 1:00 PM - 1:15 PM EST
‍
Workshop
Speaker - Ivan Lee - CEO / Founder at Datasaur

Building a custom LLM-powered chatbot for Slack can significantly enhance productivity and internal communication. This session will demonstrate how attendees can design and deploy a Slack chatbot tailored to their organizational needs in minutes, using Datasaur's easily accessible LLM Labs platform. Attendees will learn to leverage Slack’s API to build a bot that performs various tasks, including summarizing lengthy threads, generating draft responses, and assisting with FAQs.

The session will empower data scientists, product managers, and developers from diverse industries to explore the value of LLM integration in real-world scenarios. Participants will walk away with practical knowledge of setting up, deploying, and customizing their own Slack chatbot, adaptable to other platforms like Discord and WhatsApp.

Learning outcomes include understanding how to configure Slack applications, integrating LLMs through APIs, and creating practical functionalities like summarization and intelligent response generation. This session is ideal for practitioners looking to bridge the gap between AI technology and its application in organizational workflows.

Session Outline:
Module 1: Introduction to LLM Chatbots (2 minutes)
Brief overview of Slack’s API and its integration capabilities.
Address common misconceptions about AI-powered chatbots.
‍
Module 2: Setting Up the LLM Application (5 minutes)
Quick demonstration of configuring and deploying LLMs using Datasaur’s LLM Labs.
Highlighting model selection and key settings (e.g., GPT-4, Claude).
Generating API endpoints and keys for integration.
‍
Module 3: Configuring the Slack App (3 minutes)
Walkthrough of setting up Slack chatbot configurations by installing:
Chatosaur link (public): https://datasaurlabels.slack.com/marketplace/A07PAPL7L7L-chatosaur
Deploying the app to a Slack workspace.
‍
Module 4: Building and Deploying the Chatbot (5 minutes)
Overview of pre-built templates for rapid deployment.
Demonstration of chatbot functionality, including summarization and user interaction.Learning Objectives:
Understand the end-to-end process of building and deploying a Slack chatbot.
Learn to integrate and configure LLMs for custom use cases.
Gain hands-on experience with tools to simplify chatbot development.
‍
Tools Used:
Slack API and App Manifest
Datasaur’s LLM Labs (LLM configuration and deployment)
Python and supporting libraries for chatbot deployment
GitHub repositories for template-based development

Background Knowledge:
Basic coding capabilities, understanding of APIs