Advanced Certification in Agentic AI Engineering

Topics Covered

• What makes an agent 'deep': meta-cognition and self-awareness in LLMs
• Self-reflection loops: generate, critique against a rubric, revise
• Multi-turn reflection: iterating until a quality threshold is met
• Plan-and-Execute pattern: separating planning from execution
• Replanning: updating the plan mid-execution when new information arrives
• ReAct vs Plan-and-Execute: trade-offs and when to use each
• Long-term memory types: episodic, semantic, and procedural
• Building an episodic memory store with LangGraph and a vector DB
• Memory consolidation: summarising and compressing old episodic memories
• Semantic memory: storing facts and updating them across sessions
• Cross-session memory retrieval: using similarity search to recall past context
• Confidence and uncertainty estimation: flagging low-confidence answers
• Agent self-improvement: using evaluation scores to update future behaviour
• Combining reflection, planning, and memory into one unified agent architecture

Hands-On Demonstrations

• Building a Self-Critique and Revision Loop in LangGraph
• Implementing a Plan-and-Execute Agent with Mid-Run Replanning
• Adding Cross-Session Episodic Memory to an Agent

Skills Covered

• Self-Reflection Loops
• Plan-and-Execute
• Episodic Memory
• Semantic Memory
• Memory Consolidation
• Confidence Estimation
• Deep Agent Architecture

Topics Covered

• RAG failure modes: hallucination, missed retrieval, and irrelevant context
• Diagnosing RAG failures systematically with RAGAS metrics
• Agentic RAG: the agent decides whether, what, and how to retrieve
• Self-RAG: retrieve, score chunk relevance, decide to regenerate, synthesise
• Corrective RAG (CRAG): falling back to web search when local KB fails
• Advanced chunking strategies: semantic chunking, late chunking, parent-child
• Re-ranking retrieved chunks with Cohere and cross-encoder models
• HyDE: generating a hypothetical answer to improve query embedding
• Query expansion: generating multiple reformulations to broaden recall
• GraphRAG: representing documents as a knowledge graph of entities and relations
• Building a knowledge graph from documents using NetworkX
• Multi-hop reasoning: traversing the graph to answer complex questions
• Hybrid RAG: combining graph traversal with vector similarity search
• Evaluating RAG pipelines with RAGAS: faithfulness, answer relevancy, context recall
• Benchmarking Agentic RAG vs standard RAG on the same test set

Hands-On Demonstrations

• Implementing Self-RAG with Relevance Scoring and Conditional Regeneration
• Building a Corrective RAG Pipeline with Web-Search Fallback
• Constructing a Knowledge Graph and Running Multi-Hop GraphRAG Queries
• Evaluating Your RAG Pipeline End-to-End with RAGAS

Skills Covered

• Agentic RAG
• Self-RAG
• Corrective RAG
• GraphRAG
• Knowledge Graphs
• Re-ranking
• HyDE
• RAGAS Evaluation

Topics Covered

• N8N overview: visual workflow automation and its role in agentic systems
• Self-hosting N8N with Docker and configuring for production
• N8N core concepts: workflows, nodes, triggers, and credentials
• Webhook trigger node: receiving external events to kick off workflows
• OpenAI node: prompt construction, model selection, and response parsing
• Anthropic node: connecting Claude to N8N workflows
• HTTP Request node: calling any external API from a workflow
• Slack node: sending formatted messages and alerts
• Error handling in N8N: error branches, retry logic, and fallback paths
• Cron trigger: scheduling agent workflows to run on a timetable
• N8N expressions: transforming data between nodes with JavaScript
• Integrating N8N with LangGraph via HTTP webhook nodes
• Storing workflow outputs: Google Sheets, Notion, and Airtable nodes
• Deploying N8N workflows to production and managing credentials securely

Hands-On Demonstrations

• Building a Webhook-Triggered Lead Enrichment Workflow with OpenAI
• Adding Error Handling and Retry Logic to an N8N Workflow
• Scheduling a Daily Competitor Monitoring Workflow with Cron and LLM

Skills Covered

• N8N
• Visual Workflow Automation
• Webhook Triggers
• LLM Node Integration
• Error Handling
• Cron Scheduling
• N8N + LangGraph

Topics Covered

• The AI safety landscape: why guardrails are non-negotiable in production
• OWASP LLM Top 10: understanding the most critical risks
• Prompt injection attacks: anatomy, real examples, and detection strategies
• NVIDIA NeMo Guardrails: architecture, Colang language, and dialog flows
• Writing Colang rails: defining allowed and blocked topics
• NeMo input rails: validating user messages before the LLM sees them
• NeMo output rails: filtering and validating LLM responses before delivery
• Guardrails AI framework: validators, the Hub, and the Guard object
• Built-in Guardrails AI validators: toxic language, secrets, competitor mentions
• Writing custom Guardrails AI validators for domain-specific rules
• PII detection with Microsoft Presidio: entities, recognisers, and anonymisation
• Building an end-to-end safety stack: input rail, LLM, output validator, PII scrub
• Toxicity, bias, and hallucination detection tools and integrations
• Constitutional AI principles: embedding safety constraints in agent design
• Testing the safety stack: red-teaming with adversarial prompt suites

Hands-On Demonstrations

• Writing NeMo Colang Rails to Block Off-Topic and Harmful Requests
• Adding PII Detection and Redaction with Presidio and Guardrails AI
• Red-Teaming an Agent with Prompt Injections and Hardening the Defences

Skills Covered

• NeMo Guardrails
• Colang
• Guardrails AI
• Presidio
• Prompt Injection Defence
• AI Safety Design
• OWASP LLM Top 10

Topics Covered

• The three pillars of LLM observability: logs, metrics, and distributed traces
• OpenTelemetry for AI: instrumenting LangGraph agents with spans and attributes
• Exporting traces to Jaeger and interpreting the trace waterfall
• Prometheus: scrape targets, metric types, and PromQL query basics
• Grafana: building dashboards for latency, token cost, and error rate
• Arize AI and Phoenix: LLM-specific monitoring, embedding drift, and data quality
• Cost tracking per run: token budgets, alerts, and quota management
• SLA and SLO design for agent systems: what to measure and why
• Fine-tuning fundamentals: when prompting is insufficient and fine-tuning is warranted
• LoRA (Low-Rank Adaptation): intuition, hyperparameters, and implementation
• QLoRA: quantised fine-tuning for resource-constrained environments
• Building a fine-tuning dataset from LangSmith agent traces
• Training a LoRA adapter on a custom domain dataset with HuggingFace PEFT
• Evaluating a fine-tuned model vs the base model on a held-out test set
• RLHF and DPO: overview, concepts, and when to consider them

Hands-On Demonstrations

• Instrumenting a LangGraph Agent with OpenTelemetry and Building a Grafana Dashboard
• Detecting Embedding Drift in a RAG Pipeline with Arize Phoenix
• Fine-Tuning a Model with LoRA and Benchmarking Against the Base Model

Skills Covered

• OpenTelemetry
• Prometheus
• Grafana
• Arize AI / Phoenix
• LLM Observability
• LoRA
• QLoRA
• HuggingFace PEFT
• SLA/SLO Design

Topics Covered

• Docker fundamentals: images, containers, layers, and the build cache
• Writing a production Dockerfile for a Python FastAPI + LangChain application
• Multi-stage builds: separating build-time dependencies from the runtime image
• Docker Compose: defining multi-service stacks with service, network, and volume configs
• Composing a full agent stack: FastAPI, ChromaDB, Redis, and a worker service
• Environment variable management: .env files, Docker secrets, and runtime injection
• Container health checks: liveness, readiness, and graceful shutdown patterns
• Pushing images to a container registry: Docker Hub and GCP Artifact Registry
• Deploying a containerised agent to GCP Cloud Run with auto-scaling
• Deploying to AWS ECS with Fargate: task definitions and service configuration
• GitHub Actions CI/CD: build, test, push, and deploy pipeline for AI services
• Blue/green deployments: switching traffic between versions with zero downtime
• Canary deployments: gradually rolling out a new agent version
• Monitoring deployed containers: Cloud Run logs, metrics, and alerting

Hands-On Demonstrations

• Building and Running a Multi-Service Agent Stack with Docker Compose
• Writing a GitHub Actions CI/CD Pipeline for an AI Agent Service
• Deploying a Containerised Agent to GCP Cloud Run with Zero Downtime
• Implementing a Blue/Green Deployment Switch for an Agent Service

Skills Covered

• Docker
• Docker Compose
• GitHub Actions
• GCP Cloud Run
• AWS ECS
• CI/CD
• Blue/Green Deployment
• Container Security

Topics Covered

• Capstone problem selection: choosing a real-world industry use case to solve
• System architecture design: identifying components, data flows, and boundaries
• Technology selection: reasoning through LangGraph vs CrewAI vs hybrid approaches
• Designing the RAG layer: index strategy, chunking method, and retrieval approach
• Designing the multi-agent layer: agent roles, task decomposition, and delegation flow
• Integrating MCP servers: identifying which external tools the system needs
• Wiring guardrails into the architecture: input rails, output validators, PII scrubbing
• Building the core agent loop: RAG + LangGraph + tool use running end-to-end
• Connecting the front-end: Streamlit or Gradio UI wired to the FastAPI agent backend
• Instrumenting with LangSmith tracing across all components
• Adding Grafana monitoring: latency, token cost, and error rate dashboards
• Peer design review: presenting the architecture and receiving structured feedback
• Iterating on the build based on review feedback before integration testing

Hands-On Demonstrations

• Architecting the Full Capstone System and Presenting the Design
• Building the Core Agent Loop with RAG, Multi-Agent Orchestration, and Guardrails
• Wiring LangSmith Tracing and Grafana Monitoring into the Full System
• Running End-to-End Integration Tests Across All Components

Skills Covered

• System Architecture Design
• RAG Layer Design
• Multi-Agent Design
• MCP Integration
• Guardrails Integration
• LangSmith Tracing
• Grafana Monitoring

Topics Covered

• Dockerising all capstone services: writing production Dockerfiles for each component
• Writing the Docker Compose stack: linking FastAPI, ChromaDB, Redis, and the agent worker
• CI/CD pipeline for the capstone: automated testing, build, and cloud deployment
• Deploying the full stack
• Performance testing: measuring latency, throughput, and cost per query under load
• Security review: checking for prompt injection vulnerabilities, data leakage, and access control gaps
• Writing technical documentation: README, API spec, and architecture decision records
• Writing a project brief: summarising the problem, approach, results, and trade-offs
• Peer code review: reviewing a peer's codebase and providing structured written feedback
• Incorporating peer review feedback and shipping the final version
• Preparing the live demo narrative: telling the story of the system to a non-technical audience
• Live demo delivery: presenting the working system with monitoring dashboard live
• Capstone retrospective: what worked, what you would do differently, and key takeaways

Hands-On Demonstrations

• Deploying the Full Capstone Stack to Cloud with CI/CD
• Running a Performance and Security Audit on the Live System
• Delivering the Live System Demo with Real-Time Monitoring

Skills Covered

• Docker & Compose
• CI/CD Deployment
• Cloud Deployment
• Performance Testing
• Security Review
• Technical Documentation
• Live Demo Delivery

Learners should have a basic understanding of Python programming before joining the course. Familiarity with APIs, machine learning fundamentals, prompt engineering, or generative AI concepts is helpful but not mandatory. You do not need prior experience with LangChain, LangGraph, CrewAI, MCP, or other AI agent frameworks.

This course is designed for professionals and learners who want to build production-ready AI agents, autonomous AI systems, and enterprise-grade generative AI applications.

This program is especially suitable for:

Learners with a foundation in Python who want hands-on experience in modern AI engineering can also benefit from this course.

The duration for this course is 60 hours along with self-paced modules which can be completed at your own preferred pace.

After completing this agentic AI certification program, you will:

The key benefits of this Agentic AI program are:

The course covers modern AI engineering tools, frameworks, and deployment technologies used for building autonomous AI applications.

Key technologies include:

• LangChain
• LangGraph
• CrewAI
• MCP (Model Context Protocol)
• Agentic RAG and GraphRAG
• DSPy
• N8N
• FastAPI
• Streamlit
• Docker and Docker Compose
• ChromaDB and FAISS
• LangSmith and Langfuse
• OpenAI APIs and Anthropic APIs
• LoRA and QLoRA fine-tuning techniques

Model Context Protocol (MCP) is an open standard for connecting AI agents with external tools and data sources. This course teaches how to build MCP servers and integrate them with LangGraph, CrewAI, Claude Desktop, and other systems.

DSPy is a framework for programmatic prompt optimization. It replaces manual prompt engineering with measurable and self-improving prompt pipelines.

The N8N module teaches workflow automation with triggers, APIs, webhooks, retries, scheduling, and integration with LangGraph-powered AI agents.

You will learn about advanced RAG techniques including Self-RAG, Corrective RAG, HyDE, reranking, GraphRAG, and multi-hop reasoning using knowledge graphs and vector search.

This course is designed for software engineers, machine learning practitioners, AI/data scientists, and technology professionals who want to move from generative-AI fluency to building, deploying, and operating production-grade autonomous AI systems.

It is also a strong fit for technical leads, solution architects, and senior developers who need to evaluate or design agentic systems for their organisations.

You will need a modern laptop (Windows, macOS, or Linux) with at least 8 GB RAM (16 GB recommended), 50 GB free disk space, and a stable broadband connection of 5 Mbps or higher. Docker Desktop or equivalent must be installable. Detailed setup guides will be provided on your LMS.

Recordings are made available within 24 hours of each session, and batch changes are available at an additional cost if you need to defer. Mentors hold weekly office hours to help learners catch up on missed sessions, and the cohort Discord channel keeps you connected to peers and trainers between sessions.