About the Workshop
In this hands-on workshop, you will build an Agentic AI application from scratch and take it all the way to production. Starting from a simple LLM-based workflow, you will progressively introduce tool usage, ReAct-style reasoning, and LangGraph orchestration to create a system capable of making decisions, retrieving information, and taking actions.
You will connect the application to external data sources using RAG, structure and control its behavior through context engineering, and extend its capabilities with MCP and multi-agent patterns. Finally, you will package everything into a Streamlit interface and deploy it to a real cloud service.
By the end of the workshop, you will have a fully working AI knowledge assistant and a clear understanding of how to design and ship production-ready agentic systems in Python.
*Note: These are tentative details and are subject to change.
Prerequisites
-
Basic Python knowledge (functions, classes, virtual environments)
-
An OpenAI API key for LLM access
-
A Tavily API key (used for search/tool integration)
-
A Render account (free tier is sufficient) for deployment
-
Access to Google Colab and the ability to run Python locally on your machine
-
A laptop with internet connection and ability to install Python packages
Workshop Modules
- Deterministic systems vs LLM-based systems vs agentic systems
- Strengths and limitations of each approach
- When agents are necessary (dynamic decision-making, tool selection, iterative reasoning)
- When agents are overkill
- Real-world use cases in production systems
- How LLMs work in applications (prompt → response)
- Limitations of plain prompting (no memory, no actions, no control flow)
- Introduction to tool calling
- From single-step responses to multi-step reasoning
- Concept of an “agent” as a decision-making loop
- Reasoning + Acting paradigm
- Thought → Action → Observation loop
- How agents decide which tool to use
- Implementing a simple ReAct agent in Python
- Failure modes (looping, hallucinated actions, tool misuse)
- Why graphs instead of linear chains
- Core concepts: state, nodes, edges
- Designing workflows as state machines
- Conditional routing and branching logic
- Loops, retries, and termination conditions
- Building a first LangGraph agent step by step
- What tools are in agentic systems
- Designing reliable tools (clear inputs/outputs, validation)
- Integrating Python functions as tools
- Connecting external APIs (e.g. Slack, GitHub)
- Error handling and fallback strategies
- Structured outputs and tool schemas
- Why it matters: Ground the model with external knowledge and control what it sees → reduce hallucinations and improve relevance
- RAG basics: Index data and Retrieval flow
- Context design: Combine: system instructions, user input, history, retrieved data, tool outputs
Control prompt size and avoid noise
Pass structured state through LangGraph
- MCP (Model Context Protocol):
- Standard way to connect tools and external systems
- Use existing MCP servers or expose your own (simple API → MCP wrapper)
- Enables modular, scalable agent architectures
- When a single agent is not enough
- Splitting responsibilities across agents
- Common patterns:
- planner / executor
- retriever / analyzer
- generator / reviewer
- Coordination and communication between agents
- Trade-offs: complexity vs clarity
- Turning backend logic into a usable application
- Building a chat-based UI
- Handling user input and responses
- Managing session state
- Displaying structured outputs and tool results
- Basic UX considerations for AI apps
- Preparing the app for production
- Managing environment variables and API keys
- Packaging dependencies
- Deploying to a cloud service (e.g. Render)
- Running and testing the live application
- Basic monitoring and limitations
