Course Detail
Module 1: Environment Setup & Core LLM Concepts
Focus: Getting comfortable with the API layer and understanding the raw materials before building autonomy.
Core Concepts:
- Intro to AI and the architecture of AI Apps.
- Environment Setup: Windows, Python, virtual environments, and .env variables.
- Comparing LLM Providers: OpenAI, Claude, Gemini.
- Your first API calls: Text generation, image generation, and TTS (Text-to- Speech).
- Core engineering: Prompt chaining vs. single prompts.
- Practical Lab: Build a basic, conversational ChatGPT replica via terminal/web UI that handles standard memory-based text prompts and replies.
Module 2: Foundations of Agentic Reasoning
Focus: Moving from deterministic chains to autonomous mental loops.
Core Concepts:
- What is an AI Agent? Distinguishing linear workflows from autonomous agents.
- The Core Loop: Perception → Reason → Action.
- Core Prompt Patterns: Chain of Thought (CoT).
- The ReAct Protocol: Mastering how models alternate between Thought, Action, and Observation.
- Practical Lab: Implement a raw ReAct execution loop from scratch in pure Python (no frameworks). Log the agent's internal "monologue" explicitly to the console.
Module 3: Tool Use & Native Function Calling
Focus: Giving the agent an interface to the outside world.
Core Concepts:
- Function Calling: How LLMs map natural language down to structured JSON schemas.
- Connecting agents to external worlds: Web searching, database querying, and file manipulation.
- Error handling: Teaching the model to self-correct when code execution yields an error stack trace.
- Practical Lab: Build a local "File Manager Agent" that reads directories, parses markdown logs, pulls out action items, and dynamically writes clean summaries to new files based on vague commands.
Module 4: The OpenAI Agents SDK Layer
Focus: Streamlining native code using production-ready SDK abstractions and async execution
Core Concepts:
- Introduction to the OpenAI Agents SDK & asynchronous Python (asyncio).
- SDK Core Primitives: The Agent, the Trace, and the execution runner (Runner.run).
- Declaring tools cleanly using the function_tool decorator.
- Persistent states: Managing agent memory natively with Sessions and SQLiteSession.
- Practical Lab: Build a unified Travel Concierge Agent that preserves conversational state across restarts using SQLite and handles custom execution traces.
Module 5: High-Level Frameworks & Multi-Agent Teams
Focus: Scaling up architectures using specialised orchestration frameworks.
Core Concepts:
- Transitioning to high-level orchestration frameworks (LangGraph, CrewAI).
- Single-Agent limitations vs the power of Multi-Agent collaboration.
- Defining roles, cross-agent communication protocols, and design patterns (Routing, Orchestrator/Workers).
- Practical Lab: Build a 3-Agent system e.g., Air ticketing or Content Factory, using CrewAI or LangGraph, where specialized agents pass state to one another to fulfil a multi-step user goal.
Module 6: Production Orchestration, Memory & Safety
Focus: Transitioning your systems from cool prototypes to resilient, safe applications.
Core Concepts:
- Memory segmentation: Short-term contextual memory vs. Long-term memory via Vector Databases (RAG).
- Implementing Human-in-the-Loop (HTL) interaction for high-risk boundaries (approval states).
- Guardrails & System Safety: Detecting infinite logic loops and handling bad model outputs.
- Practical Lab: Build an enterprise Support Agent that dynamically parses company documentation via a vector database, writes responses, but halts execution at a terminal prompt waiting for human "Y/N" approval before finalizing actions.
Training Enrollment Form