Agent Engineering Bootcamp: Developers Edition

Welcome to the official course repository for Agent Engineering Bootcamp: Developers Edition.

This repo is for anyone and contains all code, exercises, templates, and project materials used throughout the course.

What makes this different? A structured 4-part journey from deployment efficiency to validated action. Master the complete agentic systems stack: LLM optimization, hybrid memory models (RAG + Knowledge Graphs), ReAct agents with orchestration, and production-grade evaluation frameworks. Build AI systems that are fast, intelligent, safe, and production-ready.

🔗 Visit course page • 💾 Save $200 with code 200OFF

Quick Links

Course Structure: From Efficiency to Action

Part 1: Deployment & Efficiency
Part 2: Retrieval & Memory
Part 3: Acting & Control
Part 4: Evals as Engineering Discipline
Technology Stack
What You'll Build

Recommended Resource

If you'd like to deepen your understanding of building LLM applications, refer to this book:

Build LLM Applications from Scratch

How to Use This Repo

This repo contains supplemental content for the course. Content is organized week by week, aligned with live sessions and project milestones.
Google Colab Pro is the preferred environment for running notebooks.
You may also clone the repo locally and run notebooks using Jupyter or your IDE.
Each notebook includes its own dependencies via !pip install — there is no global requirements.txt.

Cloning the Repository (Optional)

git clone https://github.com/yourusername/enterprise-rag-agents.git
cd enterprise-rag-agents
python3 -m venv venv
source venv/bin/activate

Course Curriculum

The Agentic Systems Roadmap: From Efficiency to Action

This course follows a structured path from building performant AI systems to ensuring they act safely and effectively in production.

Part 1: Deployment & Efficiency

Building the Performance & Memory Engine

Focus on Quantization and KV Caching to define what is actually deployable in the real world.

Key Topics:

LLM Deployment and Hosting
Quantization methods (4-bit, 8-bit)
KV Caching optimization
Speculative Decoding
Mixture of Experts

Notebooks:

TextSTreamer:

Bitsnbytes Quantization:

Part 2: Retrieval & Memory

Hybrid Memory Models

Integrates RAG for unstructured data and Knowledge Graphs for structured, symbolic reasoning.

Key Topics:

Naive RAG vs Agentic RAG
Agentic RAG Components
Semantic Cache implementation
Knowledge Graphs for structured reasoning
GraphRAG at scale
Text-to-Cypher conversion with LLMs
RAG vs Knowledge Graph Evaluation

Notebooks:

Upload Data to Qdrant:

Agentic RAG:

Semantic Cache:

Knowledge Graphs Basic Version:

Knowledge Graphs Advanced Version:

📊 Featured Project: RAG vs Knowledge Graph Comparison Framework

A production-ready Streamlit application that objectively compares RAG and Knowledge Graph approaches using LLM-based evaluation. Includes interactive graph visualizations showing the exact data path used for each answer.

View Full Documentation →

Interactive Demo:

cd Module_4_Knowledge_Graphs
python setup.py  # One-time setup
streamlit run app.py

Part 3: Acting & Control

Intelligence Becomes Action

Uses ReAct loops and Guardrails to ensure agents reason, act, and coordinate safely.

Key Topics:

Building LLM Agents from scratch
ReAct (Reasoning + Acting) patterns
Multi-Agent Orchestration with ADK & MCP
AI Agent Frameworks (smolagents, AutoGen, CrewAI)
Production Guardrails (Llama Guard)
Safety and control mechanisms

Notebooks:

AgentPro Starter Code:

Agent Pro from Scratch [old version]:

Agent Pro ReAct:

Smol Agents:

ADK A2A MCP:

MCP (non-adk):

Llama Guard:

Part 4: Evals as Engineering Discipline

Closing the Loop

Validates the entire stack by measuring and optimizing efficiency, reasoning quality, and safety.

Key Topics:

LLM-based evaluation frameworks
RAG vs Knowledge Graph comparison methodologies
Safety evaluation and jailbreak testing
Production monitoring and validation
Performance benchmarking

Notebooks:

Ollama jailbreak:

Technology Stack

This course uses the following tools and services:

Area	Tools / Frameworks
LLM Access	Ares API (via Traversaal.ai), OpenAI GPT-4o-mini
Agent Frameworks	ADK, A2A, CrewAI
Vector Search	FAISS (Colab), OpenSearch (optional)
Graph Databases	Neo4j Aura, NetworkX
Memory & Caching	Redis Cloud (recommended setup)
Web Interfaces	Streamlit, FastAPI
Visualizations	Pyvis, Plotly, Interactive Graph Rendering
Notebooks	Google Colab Pro (preferred), Jupyter (optional)
Deployments (Optional)	AWS Lambda, Step Functions, FastAPI
Language	Python 3.10+

You don't need to pre-install anything locally. All key dependencies are included in each notebook. g

What You'll Build

This course goes beyond theory. You'll build production-ready systems across four key phases:

Phase 1 & 2: Building the Performance & Memory Engine

Optimized LLM Deployments with quantization and KV caching
Agentic RAG Systems with advanced retrieval and semantic caching
Knowledge Graph Applications with RAG vs KG evaluation framework
Hybrid Memory Models combining structured and unstructured data

Phase 3 & 4: From Intelligence to Validated Action

ReAct Agent Systems that reason and act autonomously
Multi-Agent Workflows with ADK, A2A, and CrewAI orchestration
Production Guardrails for safe AI deployment (Llama Guard)
LLM-based Evaluators for comprehensive system validation
Interactive Dashboards using Streamlit for real-time demos

Each module includes hands-on projects you can showcase in your portfolio.

Student Feedback (Beta Cohort)

"Finally a course that moves past theory and teaches how to build AI systems that work." "Everything was practical — I now know how to apply RAG and agents in real products."

Ready to Master Multi-Agent Systems?