Comprehensive Engineering Syllabus
Generative AI & Agentic AI Engineering
From Fundamentals to Production
A hands-on program designed to help developers and technology professionals understand
Generative AI, build Agentic AI applications, and develop practical AI engineering skills
through real-world use cases.
- Duration
- 12 Weeks
- Commitment
- 6–8 Hours / Week
- Primary Language
- Python 3.11+
- Format
- Applied Labs & Capstone
Program Overview & Philosophy
This course bridges the gap between academic foundations and robust software engineering. Learners progress systematically from LLM inference and prompt serialization to building multi-agent systems, FastMCP tools, stateful LangGraph workflows, and production-ready observable services. Emphasis is placed on real engineering tradeoffs: evaluation metrics, latency, security, and enterprise recovery patterns.
Core Learning Outcomes
- Core Theory: Master transformers, attention, tokens, embeddings, and context limits.
- App Development: Build production services using Python, LangChain, and FastAPI.
- Retrieval Systems: Build enterprise RAG pipelines with vector search and quality metrics.
- Stateful Agents: Orchestrate cyclical graphs and human-in-the-loop flows with LangGraph.
- Standard Tooling: Construct reusable protocol integrations via MCP and FastMCP.
- Observability: Trace, benchmark, and evaluate reliability using LangSmith and Langfuse.
- Security & Ops: Apply prompt-injection defense, secrets isolation, and Docker CI/CD.
- Production Delivery: Ship an end-to-end Natural Language to SQL Analytics Assistant with architectural rationale.
Technology Stack & Tooling Matrix
| Domain Area | Technologies & Libraries | Industry Focus |
| Core Programming | Python, AsyncIO, Typing | Clean code, asynchronous execution |
| LLM Integration | Model APIs, LangChain core/community | Provider-agnostic abstraction |
| Backend Services | FastAPI, Pydantic v2 | Type validation, REST contracts |
| Knowledge Retrieval | RAG, Chroma/Qdrant, Embeddings | Dense semantic retrieval, hybrid search |
| Agent Orchestration | LangGraph | Stateful graphs, checkpointing |
| Tool Protocol | MCP, FastMCP | Standardized capability exposure |
| Tracing & Eval | LangSmith, Langfuse | Evals, latency, and cost telemetry |
| Testing & DevOps | pytest, Docker, GitHub Actions | Containerization & automated regression |
Prerequisites: Working knowledge of Python, REST APIs, HTTP, and JSON. No GPU or deep learning required. Capstone Included
The 12-Week Curriculum
Phase I — Foundations, Application Architecture & Retrieval
Weeks 1–4 Week 1 — AI Foundations & LLM Fundamentals
Learning Outcomes: Understand how modern LLMs work and recognize their capabilities and limitations.
Core Concepts
- AI, machine learning, deep learning, and Generative AI paradigms.
- Transformers, self-attention, tokens, embeddings, context windows.
- Pretraining, fine-tuning, inference, and next-token prediction.
- Hallucinations, temperature sampling, top-p, and architectural limits.
Hands-on Lab: Set up Python environment and build first application using direct LLM API calls.
Case Study: Benchmark rule-based vs. LLM-based support ticket classification accuracy.
Week 2 — Prompt Engineering & LLM Application Development
Learning Outcomes: Design reusable prompts and build reliable applications around LLM APIs.
Core Concepts
- Zero-shot, few-shot prompt formulation, and in-context learning.
- Dynamic prompt templates and multi-step task decomposition.
- Structured outputs, strict JSON Schema generation, and Pydantic parsing.
- Inference parameters, API error classes, exponential backoff, secrets hygiene.
Hands-on Lab: Build a Python ticket assistant parsing unstructured tickets into validated schemas.
Case Study: Customer service automation with programmatic schema checks and human escalation.
Week 3 — FastAPI for AI Applications
Learning Outcomes: Expose AI capabilities through scalable, maintainable REST APIs.
Core Concepts
- FastAPI routing, request bodies, and typed response schemas.
- Dependency injection for model providers and rate-limiting.
- Asynchronous endpoints, streaming responses (SSE), error handling.
- Authentication, API key security, and automated endpoint tests.
Hands-on Lab: Ship an asynchronous FastAPI microservice serving validated LLM-backed tasks.
Case Study: Architectural design of an AI inference microservice for mobile and web clients.
Week 4 — LangChain & LLM Application Frameworks
Learning Outcomes: Organize model calls, templates, structured outputs, and composable pipelines.
Core Concepts
- LangChain core abstractions: Models, ChatModels, and PromptTemplates.
- LCEL (LangChain Expression Language) pipelines and composition.
- Output parsers, model fallbacks, and deterministic processing.
- Tool-calling interfaces and framework vs. raw client tradeoffs.
Hands-on Lab: Refactor the ticket processing service using LangChain primitives and expose via FastAPI.
Case Study: Transitioning from ad-hoc scripts to structured, maintainable framework architectures.
Phase II — RAG Systems & Agentic Architectures
Weeks 5–8 Week 5 — Retrieval-Augmented Generation (RAG)
Learning Outcomes: Retrieve external knowledge and synthesize evidence-grounded answers.
Core Concepts
- RAG architecture, document loaders, token vs. recursive splitting.
- Dense embeddings, vector stores, and distance metrics (cosine, dot).
- Semantic search, retriever configurations, and metadata filtering.
- Context window assembly, explicit citations, and refusal/abstention logic.
Hands-on Lab: Build a document Q&A system over technical documentation using LangChain and vector stores.
Case Study: Enterprise internal policy assistant ensuring zero hallucination on corporate policies.
Week 6 — Advanced RAG & Evaluation with LangSmith
Learning Outcomes: Improve retrieval accuracy and systematically diagnose incorrect answers.
Core Concepts
- Hybrid search (BM25 + vector), query rewriting, and cross-encoder reranking.
- Isolating retrieval precision/recall from generator synthesis quality.
- Curating golden test datasets for automated regression testing.
- RAG triad metrics: Faithfulness, Answer Relevance, and Context Precision.
Hands-on Lab: Benchmark baseline vs. reranked RAG configurations and track metrics in LangSmith.
Case Study: Diagnosing and resolving retrieval failures caused by outdated and conflicting documents.
Week 7 — Agentic AI & Tool-Using Agents
Learning Outcomes: Build agents capable of reasoning, selecting tools, and solving multi-step tasks.
Core Concepts
- Workflows vs. ReAct loops: Reasoning, Action, and Observation cycles.
- LangChain agents, native tool calling, and structured function schemas.
- Argument validation with Pydantic, error recovery, and loop termination.
- Tool authorization, deterministic safeguards, and idempotency.
Hands-on Lab: Build an IT service desk agent that queries KB, inspects user records, and executes calculations.
Case Study: Operational audit of helpdesk operations: determining full automation vs. human-gated steps.
Week 8 — Stateful Workflows with LangGraph
Learning Outcomes: Orchestrate cyclical workflows with state management and human approval gates.
Core Concepts
- Graphs, nodes, conditional edges, and typed workflow state.
- State persistence, checkpointing, and time-travel debugging.
- Human-in-the-loop (HITL) interrupt patterns and approval checkpoints.
- Handling non-deterministic failures with bounded graph-level retries.
Hands-on Lab: Build a workflow that drafts a transaction, halts for human approval, and resumes on input.
Case Study: Enterprise refund processing engine with mandatory supervisor sign-off thresholds.
Phase III — Tool Protocols, Production & Capstone
Weeks 9–12 Week 9 — MCP & FastMCP Integration
Learning Outcomes: Build reusable business integrations using Model Context Protocol (MCP).
Core Concepts
- MCP architecture: Host, Client, and Server specifications.
- Tools, Resources, and Prompts within the standardized protocol.
- Implementing Python FastMCP servers and type-safe tool registries.
- Securing tool exposure and bridging MCP endpoints into LangGraph agents.
Hands-on Lab: Build a FastMCP server exposing database operations and connect it to an agent.
Case Study: Standardizing enterprise tools via MCP across varied client interfaces.
Week 10 — Advanced Agent Architecture & Multi-Agent Systems
Learning Outcomes: Design resilient multi-agent patterns while managing system complexity and cost.
Core Concepts
- Single-agent vs. multi-agent topology: Supervisor, Router, and Delegator.
- Context window management, memory systems, and shared graph state.
- Mitigating token bloat, cascading errors, and latency bottlenecks.
Hands-on Lab: Implement a multi-agent triage system with supervisor routing and specialist nodes.
Case Study: Cost and latency tradeoff analysis: RAG vs. Single ReAct vs. Multi-Agent.
Week 11 — Production Engineering, Langfuse & Deployment
Learning Outcomes: Deploy monitored, secure, and resilient AI systems into production.
Core Concepts
- Automated testing harnesses using pytest and deterministic mock fixtures.
- Langfuse tracing: tracking token consumption, latency budgets, and costs.
- Security: prompt injection mitigation, data exfiltration defense, scoped tools.
- Docker containerization, environment variable management, and CI/CD pipelines.
Hands-on Lab: Instrument telemetry with Langfuse, add pytest CI suites, and package in Docker.
Case Study: Enterprise pre-deployment readiness audit covering security and SLA standards.
Week 12 — Capstone Defense & AI System Design
Learning Outcomes: Deliver an end-to-end production AI copilot with rigorous evaluation.
Core Concepts
- Translating business requirements into resilient AI architectures.
- Engineering tradeoff justification: LLM vs. RAG vs. Agentic workflows.
- Production readiness reporting: quality benchmarks, latency, cost analysis.
Hands-on Lab: Deliver complete Natural Language to SQL Analytics Assistant with API, stateful graphs, MCP, and observability.
Deliverable: Complete GitHub repository with test suite, Dockerfile, and architecture document.
