🤖 AI Agent Workshop - Interactive Notebooks

Welcome to the AI Agent Workshop! This hands-on learning experience will teach you how to build autonomous AI agents using Python and modern LLMs.

Regional pricing is available for eligible learners, with discounts of up to 60% in supported regions. Start here: https://www.learnwithparam.com/ai-bootcamp

🌟 What You'll Learn

Through 9 interactive Jupyter notebooks, you'll master:

1. 🧠 Agent Fundamentals - Build your first stateful agent from scratch.
2. 🔄 ReAct Pattern - Implement the Reasoning + Acting loop manually.
3. 🛠️ Tool Integration - Use Native Function Calling with JSON schemas.
4. ⚡ Agent Loop - Automate multi-step reasoning with execution loops.
5. 💾 Memory Basics - Manage long conversations with sliding windows and summaries.
6. ⛓️ AI Workflows - Chain multiple specialized agents into a team.
7. 🛡️ Error Handling - Build self-correcting agents that handle hallucinations.
8. 🤝 Human-in-the-loop - Secure your agents with human approval points.
9. 🚀 Practical Agent - Build a complete "Research & Publishing Assistant".

🚀 Quick Start

Prerequisites

• Python 3.10+
• uv (will be installed automatically if using make setup)
• API key (Google AI Studio recommended for beginners)

Fast Track (5 minutes)

1. Get your API key: Google AI Studio
2. Setup & Run:

   cd ai-agent-workshop
   
   # One command to setup .env, install dependencies, and run!
   make dev

3. Configure: The first time you run it, it will create .env. Edit .env and add your API key, then run make dev again.
4. Start Learning: Open 01-agent-fundamentals.ipynb at http://localhost:8888

📚 Notebook Guide

Recommended Learning Path

Follow the notebooks in order - each builds on concepts from previous ones:

Notebook	Topic	Time	What You'll Build
01	Agent Fundamentals	30 min	Stateful "Sarah" assistant
02	ReAct Pattern	45 min	Thought-Action-Observation loop
03	Tool Integration	45 min	Smart home tools with schemas
04	Agent Loop	45 min	Recursive execution class
05	Memory Basics	45 min	Windowed & Summary memory
06	AI Workflows	45 min	Sequential research team
07	Error Handling	45 min	Self-correcting tool handler
08	Human-in-the-loop	45 min	Transfer-approval guardrails
09	Practical Agent	60 min	Full "Research & Publish" assistant

🎯 Learning Approach

Each notebook follows a consistent, beginner-friendly structure:

📖 Scenario-Based Learning

Every concept is introduced through real-world scenarios you can relate to.

🛠️ Hands-On Practice

• Working code examples you can run immediately
• Discussion questions to deepen understanding
• Challenge tasks to test your skills
• Real-world applications you can build

💡 Key Insights

Look for these throughout each notebook:

• 💡 Key Insight - Important concepts explained simply
• ❓ Discussion Question - Think critically about what you learned
• 🎯 Challenge Task - Apply your knowledge
• ⚠️ Important Note - Critical information to remember

🔑 API Keys & Models

Supported Providers

The notebooks work with multiple AI providers:

Provider	Models	Cost	Best For
Google (Gemini)	gemini-2.0-flash-exp	Free tier!	Beginners, all notebooks
OpenAI	gpt-4o, gpt-4o-mini	Paid	Production apps
Anthropic	claude-3-5-sonnet	Paid	Advanced reasoning

Getting API Keys

• Google AI Studio (Recommended for beginners): https://aistudio.google.com/apikey
• OpenAI: https://platform.openai.com/api-keys
• Anthropic: https://console.anthropic.com/

💻 Running the Notebooks

We provide a Makefile to make common tasks easy. Run make help to see all commands.

Option 1: Local Development (Recommended)

This automatically checks for uv (installing it if needed), creates a virtual environment, installs dependencies, and starts JupyterLab.

# 1. Setup & Install
make dev

Note: The first time you run this, it will create .env. You must edit .env and add your API key before the notebooks will work!

Manual Steps (if you prefer):

make setup      # Create .env and install uv
make install    # Install dependencies (uv sync)
make run        # Start JupyterLab (uv run jupyter lab)

Option 2: Docker (Isolated)

Perfect for keeping your system clean or ensuring consistency.

make setup      # Create .env (Edit to add API key)
make build      # Build image
make up         # Start container

• Access: http://localhost:8888
• Stop: make down
• Logs: make logs

Option 3: VS Code

1. Install the Jupyter extension
2. Open the notebook
3. Select Kernel -> Python Environments
4. Run cells with the play button

🎓 Learning Tips

For Complete Beginners

1. Start with Notebook 1 - Don't skip ahead!
2. Read the scenarios - They make concepts relatable
3. Run every code cell - Learning by doing is key
4. Try the challenges - They solidify your understanding
5. Ask questions - Use discussion questions to think deeper

For Experienced Developers

1. Skim the basics - But don't skip the "Key Insights"
2. Focus on challenges - Test your understanding
3. Experiment - Try different models and parameters
4. Build real apps - Use the "Real-World Applications" as starting points

🏗️ What You Can Build

After completing these notebooks, you'll be able to build:

• 🤖 Personal research assistant
• 📊 Data analysis agent
• 📧 Email automation bot
• 🛠️ Custom tool-using agents

📖 Additional Resources

Documentation

• LiteLLM Docs - Multi-provider AI library
• Google AI Studio - Test Gemini models
• LangChain - Framework for LLM apps

Next Steps

After completing these notebooks:

1. Build a real project using what you learned
2. Explore advanced topics (Multi-agent systems, RAG)
3. Deploy your AI agent to production
4. Share your learnings with others!

🤝 Contributing

Found a typo? Have a suggestion? Want to add an example?

• Open an issue
• Submit a pull request
• Share your feedback

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

---

🎉 Ready to Start?

1. ✅ make setup
2. ✅ make dev
3. ✅ Open 01-agent-fundamentals.ipynb
4. ✅ Start building!

Happy learning! 🚀

---

Questions? Stuck on something? Remember: Every expert was once a beginner. Take your time, experiment, and enjoy the journey!