Agentic AI Workshop

A hands-on workshop that takes you from zero to a working AI agent in about an hour, using Python, LangChain, and Groq (a free, very fast LLM API). No GPU and no real hardware/sensors required -- every project runs on mocked data (CSV files, lists, strings) so it works on any laptop.

What's in this repo

Path	What it's for
slides/	Slide deck, printable cheat sheet, and the live-coding narrative used during the session
agentic-ai-workshop-boilerplate/	The code: setup checker, step-by-step phases, and three track projects

1. Get the cheat sheet

If you just want the quick-reference handout, grab slides/AI_Agent_Workshop_Cheatsheet.pdf. It's the same material as the phase files below, condensed to one page -- useful to keep open while you code, or to take away after the workshop.

The full slide deck is slides/AI_Agent_Workshop_Slides.pptx, and slides/live_coding_narrative.md has the script used to build the demo live, step by step.

2. Get a free Groq API key

The workshop runs entirely on Groq's free tier -- no credit card, no GPU.

1. Go to console.groq.com/keys
2. Sign up (or log in)
3. Click Create API Key and copy it
4. Paste it into your .env file (see setup below) as GROQ_API_KEY

Do this before the workshop if you can, so build time isn't spent waiting on signup emails.

3. Set up and run the code

Everything for setup and running agents lives in agentic-ai-workshop-boilerplate/ -- its own README has the full details, but the short version:

cd agentic-ai-workshop-boilerplate

# create and activate a virtual environment (recommended)
python -m venv venv
venv\Scripts\activate        # Windows
source venv/bin/activate     # Mac/Linux

# install dependencies
pip install -r requirements.txt

# create your .env file and add the Groq key from step 2
copy .env.example .env        # Windows
cp .env.example .env          # Mac/Linux

# verify everything works before the session starts
python phase_00_setup/check_environment.py

If that last command prints All checks PASSED, you're ready to go.

4. Learn step by step

Work through the numbered phases in order -- each one is a small, heavily-commented, standalone script that proves one new concept:

Phase	File	What it proves
0	phase_00_setup/check_environment.py	Your setup + Groq key actually work
1	phase_01_first_agent/hello_agent.py	The core agent loop, one tool
2	phase_02_add_a_tool/agent_with_tool.py	Adding a second tool (giving your agent a new skill)
3	phase_03_memory/agent_with_memory.py	The agent remembering earlier turns
4	phase_04_multi_step_task/agent_task_chain.py	Looping through a whole list until the agent decides it's done

Run any phase directly, e.g. python phase_01_first_agent/hello_agent.py. You don't need to finish earlier phases to run a later one.

5. Build your own agent (the track projects)

Once you know the pattern, pick one track under agentic-ai-workshop-boilerplate/tracks/ and build it end to end:

• tracks/robotics/ -- Rescue Drone Triage Agent
• tracks/ai/ -- The Study Group That Never Sleeps (multi-agent)
• tracks/cybersecurity/ -- Catch the Intruder

Each track has a starter/ scaffold to build from and a reference_solution/ to compare against once you've had a go. When you want to start a brand-new agent from scratch, copy template/new_agent_template.py -- same pattern, with TODO markers instead of a finished example.

Troubleshooting

Common Groq/setup issues (invalid key, rate limits, retired models, ModuleNotFoundError, tool-calling not triggering) are covered in the boilerplate README's Troubleshooting section.

6. Going to production: libraries worth knowing

This workshop hand-rolls a simple agent loop so you understand what's actually happening under the hood. Once you get it, here are established, production-grade libraries and tools that solve the same problems (and more) so you don't have to build them yourself:

Agent frameworks & orchestration

• LangChain -- the library this workshop is built on; chains, tools, retrieval, and integrations for almost every LLM provider
• LangGraph -- stateful, graph-based orchestration for multi-step and multi-agent workflows
• CrewAI -- role-based multi-agent orchestration (great fit for the "Study Group" style track)
• Microsoft AutoGen -- multi-agent conversation framework from Microsoft Research
• Claude Agent SDK -- Anthropic's SDK for building custom agents on top of Claude
• OpenAI Agents SDK -- OpenAI's lightweight framework for agentic apps

Retrieval & knowledge

• LlamaIndex -- data framework for connecting LLMs to your own documents/databases (RAG)
• Haystack -- production RAG and search pipelines

Reliability, structure & guardrails

• Instructor -- get structured, validated output (Pydantic models) from any LLM
• Guardrails AI -- input/output validation and safety rails for LLM apps
• LiteLLM -- one API to call 100+ LLM providers (swap Groq/OpenAI/Anthropic/etc. without changing code)

Observability & evaluation

• LangSmith -- tracing, debugging, and evaluation for LLM apps
• Langfuse -- open-source LLM observability and analytics

Model access

• Groq -- the free, fast inference API used in this workshop
• Ollama -- run open-source models locally, no API key needed

License

This repository is licensed under CC BY 4.0 -- you're free to use, adapt, and reuse everything here (including for your own courses or commercial projects), as long as you credit the original author and link back to this repo.

If this material helped you, please consider giving the repo a star -- it's the easiest way to support the project and helps other learners find it.