New Course Enquiry :
Best Seller
Advanced Certification in Agentic AI Engineering
Advanced Certification in Agentic AI Engineering
Have queries? Ask us+1 833 429 8868 (Toll Free)
68810 Learners4.8 45931 Ratings
View Course Preview Video
Live Online Classes starting on 15th Aug 2026
Why Choose Edureka?
Instructor-led Advanced Agentic AI live online Training Schedule
Flexible batches for you
899
Registration Closes 13th Aug 2026
Powered By![PayPal Payment mode]( "PayPal Payments")
Why enroll for Advanced Certification in Agentic AI Engineering?
Agentic AI Engineering Training Benefits
The Agentic AI market is anticipated to grow at a CAGR of 45.8% from 2025 to 2030, with 90% of businesses anticipating it to be crucial to their future success. As enterprises adopt agentic AI, the demand for experts in autonomous AI systems is soaring. Our project-based program empowers you with cutting-edge, end-to-end expertise — every live module culminates in a real industry build, giving you a portfolio of production-shape systems to take to your next role.
Annual Salary
Hiring Companies
Annual Salary
Hiring Companies
Annual Salary
Hiring Companies
Annual Salary
Hiring Companies
Why Advanced Certification in Agentic AI Engineering from edureka
Live Interactive Learning
- World-Class Instructors
- Expert-Led Mentoring Sessions
- Instant doubt clearing
Hands-On Project Based Learning
- Industry-Relevant Projects
- Course Demo Dataset & Files
- Quizzes & Assignments
Industry Recognised Certification
- Edureka Training Certificate
- Graded Performance Certificate
- Certificate of Completion
Like what you hear from our learners?
Take the first step!
About your Advanced Certification in Agentic AI Engineering
Skills Covered
Tools Covered
Advanced Agentic AI Course Curriculum
Curriculum Designed by Experts
Module 01: Python & AI Dev Environment Setup
12 Topics
Topics
- Overview of the Agentic AI ecosystem and where Python fits
- Setting up Python with pyenv for version management
- Creating and managing virtual environments using venv and conda
- Configuring VS Code with AI-friendly extensions and settings
- Setting up Jupyter Lab for interactive AI experimentation
- Understanding Python project structure for production AI apps
- Managing dependencies with pip and requirements.txt
- Securely managing API keys using python-dotenv and .env files
- Introduction to Git: initialising repos, branching, and committing
- Pushing AI projects to GitHub with a proper .gitignore
- Writing asynchronous Python with asyncio for concurrent LLM calls
- Comparing sequential vs concurrent API calls: performance benchmarking
![skill]( "Hands On Experience")
- Setting Up Your Python AI Project from Scratch
- Managing API Keys Securely with python-dotenv
- Running Concurrent LLM Calls with asyncio
![skill]( "skill you will learn")
- Python
- Virtual Environments
- Git & GitHub
- asyncio
- Project Structure
- Secret Management
Module 02: FastAPI, Streamlit & Gradio for AI Apps
13 Topics
Topics
- REST API fundamentals: HTTP methods, status codes, request/response lifecycle
- FastAPI project structure: routers, models, and dependency injection
- Defining Pydantic models for request validation and response schemas
- Building async FastAPI endpoints for LLM-powered routes
- Streaming LLM responses using Server-Sent Events (SSE)
- Handling file uploads in FastAPI for document processing pipelines
- Running and testing FastAPI with Uvicorn and Swagger UI
- Streamlit fundamentals: layout, widgets, session state, and caching
- Building a real-time streaming chat UI in Streamlit
- Gradio components: text, file, image inputs and markdown outputs
- Creating shareable Gradio demos and deploying to HuggingFace Spaces
- Wiring a Streamlit or Gradio front-end to a FastAPI backend
- Comparing Streamlit vs Gradio: when to use which
![skill]( "Hands On Experience")
- Building Your First FastAPI LLM Endpoint
- Streaming AI Responses Live in a Streamlit UI
- Creating a Shareable AI Demo with Gradio
- Connecting a Gradio Front-End to a FastAPI Backend
![skill]( "skill you will learn")
- FastAPI
- Streamlit
- Gradio
- REST API Design
- Server-Sent Events
- Uvicorn
- Pydantic
Module 03: LLM Fundamentals, Context & Prompt Engineering
14 Topics
Topics
- How large language models work: tokenisation, attention, and next-token prediction
- Understanding context windows: limits, costs, and implications for agents
- The OpenAI API: chat completions, parameters, and response structure
- The Anthropic API: messages format, system prompts, and model differences
- Structuring system prompts for domain-expert personas
- Zero-shot, one-shot, and few-shot prompting patterns
- Chain-of-Thought (CoT) prompting for complex reasoning tasks
- Tree-of-Thought (ToT) for branching multi-path reasoning
- ReAct prompting: combining reasoning and action steps
- Structured outputs using JSON mode and response schemas
- Function calling: defining tools and routing user intent
- Context management strategies: chunking, summarisation, and windowing
- Measuring and optimising token usage with tiktoken
- Evaluating and benchmarking LLM output quality
![skill]( "Hands On Experience")
- Comparing Zero-Shot, Few-Shot, and Chain-of-Thought Prompts
- Extracting Structured Data with JSON Mode and Pydantic
- Routing User Intent with Function Calling
![skill]( "skill you will learn")
- Prompt Engineering
- OpenAI API
- Anthropic API
- Context Management
- Function Calling
- JSON Mode
- Token Optimisation
Module 04: Embeddings, Vector Databases & Semantic Search
13 Topics
Topics
- What vector embeddings are and why they matter for AI agents
- Embedding models: OpenAI text-embedding-3 and HuggingFace sentence-transformers
- Generating embeddings for text, documents, and structured data
- ChromaDB architecture: collections, documents, metadata, and IDs
- CRUD operations and metadata filtering in ChromaDB
- FAISS index types: Flat L2, IVF, HNSW — trade-offs explained
- Building and querying a FAISS index from a document corpus
- Nearest-neighbour retrieval: understanding similarity metrics (cosine, L2, dot product)
- Hybrid search: combining BM25 keyword scoring with semantic vector scores
- Chunking strategies for effective embedding: fixed, sentence, and recursive
- Benchmarking ChromaDB vs FAISS: speed, accuracy, and scalability
- Visualising embedding clusters with UMAP to understand semantic groupings
- RAG architecture overview: retriever, generator, and the full pipeline
![skill]( "Hands On Experience")
- Building a Semantic Search Engine with ChromaDB
- Benchmarking FAISS Flat vs HNSW Retrieval Speed
- Implementing Hybrid Keyword and Semantic Search
- Visualising Document Embeddings with UMAP
![skill]( "skill you will learn")
- Vector Embeddings
- ChromaDB
- FAISS
- Semantic Search
- Hybrid Search
- sentence-transformers
- RAG Fundamentals
Module 05: LangChain Core - Chains, Memory & RAG
12 Topics
Topics
- LangChain architecture: runnables, the pipe operator, and the LCEL paradigm
- Building chains with LCEL: prompt | llm | parser patterns
- Prompt templates: ChatPromptTemplate, MessagesPlaceholder, and partial templates
- Output parsers: StrOutputParser, JsonOutputParser, and PydanticOutputParser
- Conversational memory types: BufferMemory, SummaryMemory, VectorStoreMemory
- Maintaining multi-turn conversation history across sessions
- Document loaders: PDF, web, CSV, Notion, and custom loaders
- Text splitters: RecursiveCharacterTextSplitter and SemanticChunker
- Building a RAG pipeline: loader, splitter, embedder, retriever, generator
- Retriever types: VectorStoreRetriever, MultiQueryRetriever, ContextualCompressionRetriever
- LangChain callbacks and hooks for logging and monitoring
- Chaining multiple retrievers and combining results
![skill]( "Hands On Experience")
- Building an LCEL Chain with Memory for Multi-Turn Conversations
- Creating a RAG Pipeline over a PDF Knowledge Base
- Comparing Multi-Query vs Single-Query Retrieval Quality
![skill]( "skill you will learn")
- LangChain
- LCEL
- RAG Pipelines
- Conversational Memory
- Document Loading
- Text Splitting
- Retrieval Strategies
Module 06: LangChain Agents & Tool Use
12 Topics
Topics
- Agent fundamentals: perception, reasoning, action, and observation loop
- ReAct agent pattern: interleaving reasoning traces and tool calls
- Plan-and-Execute pattern: generating a plan first, then executing steps
- LangChain built-in tools: Tavily Search, Python REPL, Wikipedia, and DuckDuckGo
- Creating custom tools with the @tool decorator and StructuredTool
- Defining tool input schemas with Pydantic for safe structured arguments
- AgentExecutor: configuration, max iterations, early stopping, and verbose mode
- Structured output agents: forcing final answers into typed Pydantic objects
- Connecting agents to SQL databases with SQLDatabaseToolkit
- Multi-step reasoning: chaining tool outputs as inputs to subsequent tool calls
- Handling tool failures: try/except patterns and automatic retry logic
- Streaming intermediate agent steps to a UI in real time
![skill]( "Hands On Experience")
- Building a ReAct Agent with Web Search and Python REPL Tools
- Connecting an Agent to a SQL Database for Natural Language Queries
- Adding Retry Logic and Error Handling to a Tool-Calling Agent
![skill]( "skill you will learn")
- LangChain Agents
- ReAct Pattern
- Custom Tool Development
- AgentExecutor
- SQL Agent
- Structured Output
- Tool Error Handling
Module 07: LangGraph - Stateful Workflows & Routing
13 Topics
Topics
- Why LangGraph: limitations of linear chains for complex agentic workflows
- Core LangGraph concepts: nodes, edges, and the state schema
- Defining a TypedDict state and passing it through the graph
- Building a StateGraph: adding nodes, setting entry points, and compiling
- Conditional edges: routing to different nodes based on state values
- MessageGraph for chat-style workflows with message history
- Streaming node-by-node output during graph execution
- Adding human-readable labels and descriptions to graph nodes
- Visualising and debugging graphs in LangGraph Studio
- Building a specialist routing system: classifier node + expert nodes
- Handling terminal states: defining END conditions and exit paths
- Composing reusable node functions with clean state interfaces
- Testing individual nodes in isolation before wiring the full graph
![skill]( "Hands On Experience")
- Building a Conditional Routing Graph with Specialist Nodes
- Streaming Live Node-by-Node Output in LangGraph
- Debugging and Visualising Your Graph in LangGraph Studio
- Building an Order-Processing State Machine with Fail and Retry States
![skill]( "skill you will learn")
- LangGraph
- StateGraph
- Conditional Routing
- Graph Compilation
- LangGraph Studio
- Stateful Agent Design
- Node Streaming
Module 08: LangGraph - Cycles, HIL & Persistence
13 Topics
Topics
- Cycles and loops: when and why to add feedback loops to a graph
- Implementing self-correction loops: generate, evaluate, revise
- Human-in-the-loop (HIL): understanding interrupt_before and interrupt_after
- Pausing a graph, collecting human input, and resuming from a checkpoint
- Building approval gate workflows: draft, review, approve, publish
- Checkpointers: what they are and why persistence matters for agents
- SQLite checkpointer: setup, configuration, and state recovery
- Redis checkpointer: setup for high-throughput production environments
- Resuming an interrupted workflow after a simulated crash
- The Send API: dispatching work to parallel worker nodes
- Aggregating parallel node results back into a shared state
- Sub-graphs: building modular graph components and composing them
- Sharing state across parent and sub-graphs safely
![skill]( "Hands On Experience")
- Adding a Human Approval Gate with Interrupt and Resume
- Implementing SQLite Checkpointing and Crash Recovery
- Fanning Out Tasks to Parallel Nodes with the Send API
![skill]( "skill you will learn")
- Human-in-the-Loop
- LangGraph Checkpointers
- SQLite Persistence
- Redis Persistence
- Parallel Execution
- Sub-graph Composition
- Cycle Design
Module 09 - LangSmith - Tracing, Evaluation & Testing
13 Topics
Topics
- Why observability matters for LLM applications in production
- LangSmith platform overview: projects, runs, traces, and feedback
- Instrumenting LangChain and LangGraph runs with LangSmith tracing
- Inspecting individual spans: inputs, outputs, latency, and token cost
- Creating evaluation datasets: golden QA pairs and edge cases
- Running automated evaluations with built-in LangSmith evaluators
- LLM-as-judge evaluation: writing a custom grading prompt
- Heuristic evaluators: rule-based checks for format, length, and keywords
- Regression testing: comparing two prompt versions on the same dataset
- A/B testing agent behaviours: setting up experiments and tracking metrics
- Annotating runs with human feedback for RLHF dataset creation
- Production monitoring dashboards: latency, error rate, and cost over time
- Setting up alerts for anomalous agent behaviour in production
![skill]( "Hands On Experience")
- Tracing a LangGraph Agent End-to-End in LangSmith
- Running an Automated Evaluation Suite with LLM-as-Judge
- Setting Up an A/B Experiment to Compare Two Agent Strategies
![skill]( "skill you will learn")
- LangSmith
- LLM Tracing
- Automated Evaluation
- LLM-as-Judge
- Regression Testing
- A/B Testing
- Production Monitoring
Module 10: Model Context Protocol: Architecture & Custom Servers
14 Topics
Topics
- What is the Model Context Protocol and why Anthropic created it
- MCP architecture: hosts, clients, and servers — roles and responsibilities
- The three MCP primitives: resources, tools, and prompts
- JSON-RPC 2.0 transport layer: stdio and HTTP/SSE communication
- Setting up the MCP Python SDK and scaffolding a minimal server
- Defining and exposing custom tools from an MCP server
- Defining resource endpoints that expose live or static data sources
- Implementing prompt templates as MCP primitives
- Tool discovery and capability negotiation between client and server
- Connecting a custom MCP server to Claude Desktop
- Connecting a custom MCP server to VS Code Copilot
- MCP security model: permission scopes and access control
- Server-side input validation and request sanitisation
- Debugging MCP servers with logging and the MCP Inspector tool
![skill]( "Hands On Experience")
- Scaffolding and Connecting Your First Custom MCP Server
- Exposing a Live Data API as an MCP Resource Endpoint
- Implementing Permission Checks and Input Validation in MCP
- Debugging an MCP Server with the MCP Inspector Tool
![skill]( "skill you will learn")
- Model Context Protocol
- MCP Python SDK
- Custom MCP Servers
- Claude Desktop Integration
- Tool Discovery
- MCP Security
- JSON-RPC
Module 11: MCP - Ecosystem Integrations
12 Topics
Topics
- Overview of the MCP ecosystem: official and community servers
- SQLite MCP server: exposing schema, running queries, and returning results
- Filesystem MCP server: safe file read, write, list, and move operations
- GitHub MCP server: managing issues, PRs, branches, and comments via Claude
- Playwright MCP server: browser automation and structured data extraction
- Chaining multiple MCP servers in a single Claude session
- Using MCP servers as tools inside LangChain agents
- Using MCP servers as tools inside LangGraph nodes
- Integrating MCP into a CrewAI agent as an external tool
- Building a report pipeline: SQLite MCP query to Filesystem MCP write
- Security considerations when chaining multiple MCP servers
- Production deployment patterns for MCP servers
![skill]( "Hands On Experience")
- Chaining SQLite MCP and Filesystem MCP to Build a Report Pipeline
- Managing a GitHub Repository via Claude and the GitHub MCP Server
- Automating Browser Data Extraction with Playwright MCP
![skill]( "skill you will learn")
- SQLite MCP
- GitHub MCP
- Playwright MCP
- Filesystem MCP
- Multi-MCP Chaining
- MCP + LangGraph
- MCP + CrewAI
Module 12: Deep Agents - Reflection, Planning & Long-Term Memory
12 Topics
Topics
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- Self-Reflection Loops
- Plan-and-Execute
- Episodic Memory
Module 13: CrewAI - Multi-Agent Orchestration & Integration
14 Topics
Topics
- CrewAI philosophy: role-based agents working as a collaborative team
- Core components: Agent, Task, Crew, and Process
- Defining agents: role, goal, backstory, and tools
- Defining tasks: description, expected output, and agent assignment
- Sequential process: tasks execute in order with output passed forward
- Hierarchical process: a manager agent routes and delegates tasks
- Inter-agent delegation: agents handing off work to more specialised peers
- Adding LangChain tools to CrewAI agents
- Adding MCP servers as tools within a CrewAI agent
- Combining CrewAI with LangGraph: Crew as a node in a stateful graph
- Parallelising research tasks across multiple agents simultaneously
- Handling crew failures: retry strategies and fallback agents
- Output parsing and structured results from a crew run
- Evaluating crew quality: scoring the final output against a rubric
![skill]( "Hands On Experience")
- Building a Three-Agent Sequential Research and Writing Crew
- Switching to Hierarchical Mode and Observing Manager Delegation
![skill]( "skill you will learn")
- CrewAI
- Multi-Agent Orchestration
- Role-Based Design
- Hierarchical Process
- CrewAI + MCP
- CrewAI + LangGraph
Module 14 - Agentic RAG & GraphRAG
15 Topics
Topics
- 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, synthesis
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- Agentic RAG
- Self-RAG
- Corrective RAG
- GraphRAG
- Knowledge Graphs
- Re-ranking
Module 15: Agentic Workflows with N8N
12 Topics
Topics
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- N8N
- Visual Workflow Automation
- Webhook Triggers
- LLM Node Integration
Module 16: Guardrails: NeMo, Guardrails AI & Safety
11 Topics
Topics
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- NeMo Guardrails
- Colang
- Guardrails AI
- Presidio
Module 17: Monitoring, Evaluation & Fine-Tuning
15 Topics
Topics
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- OpenTelemetry
- Prometheus
- Grafana
- Arize AI / Phoenix
- LLM Observability
Module 18: Dockerizing & Deploying AI Agents
10 Topics
Topics
- 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
![skill]( "Hands On Experience")
- Building and Running a Multi-Service Agent Stack with Docker Compose
- Writing a GitHub Actions CI/CD Pipeline for an AI Agent Service
![skill]( "skill you will learn")
- Docker
- Docker Compose
- GitHub Actions
- GCP Cloud Run
- AWS ECS
- CI/CD
Module 19: Capstone Part I: Architecture, Build & Integration
13 Topics
Topics
- 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 RAG layer: index strategy, chunking method, and retrieval approach
- 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
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- System Architecture Design
- RAG Layer Design
- Multi-Agent Design
- MCP Integration
Module 20: Capstone Part II: Deployment
13 Topics
Topics
- 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
- 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
![skill]( "Hands On Experience")
- 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
![skill]( "skill you will learn")
- Docker & Compose
- CI/CD Deployment
- Cloud Deployment
Module 21: Vibe Coding for Developers (Self-paced)
10 Topics
Topics
- Vibe Coding Fundamentals
- Vibe Coding Tools Overview
- GitHub Copilot Setup and Features
- Chat and Interactive Coding
- Code Quality and Testing
- Advanced Copilot Techniques
- Cursor Fundamentals
- Codebase Intelligence
- Composer
- Development with Cursor
![skill]( "Hands On Experience")
- Working with GitHub Copilot
- Building Projects with Cursor
![skill]( "skill you will learn")
- Vibe Coding
- GitHub Copilot
- Cursor AI
Module 22: No-Code Workflow Automation with Zapier and Make (Self-paced)
10 Topics
Topics
- Zapier Fundamentals and Workflows
- Trigger and Action Patterns
- Multi-Step Zaps for Complex Logic
- Zapier API for Custom Integrations
- Zapier Tables for Agent Data Storage
- Make (Integromat) Overview and Modules
- Make Scenarios and Advanced Routing
- Webhooks and API Integration in Make
- Connecting Python Agents to Zapier/Make
- Scaling No-Code Automation
![skill]( "Hands On Experience")
- Working with Zapier and Make
![skill]( "skill you will learn")
- Zapier automation
- Make workflows
- No-code integrations
- Hybrid agent-automation
Module 23: Programmatic Prompting with DSPy (Self-paced)
11 Topics
Topics
- Introduction to DSPy
- DSPy Modules and Signatures
- ChainOfThought and Predict Modules
- ReAct Modules in DSPy
- DSPy Optimizers (BootstrapFewShot, MIPRO)
- Compiling and Validating DSPy Programs
- Metric Functions and Evaluation
- DSPy with Multiple LLMs
- Building Self-Improving Pipelines
- DSPy vs Manual Prompting Trade-offs
- DSPy Production Deployment
![skill]( "Hands On Experience")
- Build a Self-Improving Prompt Optimization System with DSPy
![skill]( "skill you will learn")
- DSPy framework
- Programmatic prompting
- Prompt optimization
- Self-improving systems
Module 24: Agent Interoperability: ACP, ANP & A2A Protocols (Self-paced)
11 Topics
Topics
- Agent Interoperability Challenge
- Agent-to-Agent (A2A) Protocol Overview
- A2A SDK and Implementation
- Agent Communication Protocol (ACP) by IBM BeeAI
- Agent Network Protocol (ANP) with DIDs
- Agent Cards for Capability Discovery
- Cross-Framework Agent Communication
- Building Multi-Protocol Gateways
- Security and Trust in Agent Networks
- Enterprise Agent Federation
- Future Standards and Governance
![skill]( "Hands On Experience")
- Build an Interoperable Multi-Framework Agent Network
![skill]( "skill you will learn")
- Agent protocols
- Cross-framework interop
- Agent networks
- Protocol governance
Module 25: Generative AI and LLM Security (Self-paced)
13 Topics
Topics
- Threats in Generative AI Systems
- Common Attack Vectors in Generative AI Systems
- Model Theft and Extraction Attacks
- Mitigation Strategies for GenAI Risks
- LLM-Specific Threats and Risks
- Aligning LLM Output to Security Objectives
- Securing AI Training Data and Pipelines
- Risks in AI Model Hubs and Repositories
- Dependency Scanning and Third-Party Model Risks
- Bias, Fairness, and Ethical Design in AI Systems
- Regulatory and Compliance Standards
- Multimodal AI Threat Intelligence
- Defending Cyber Operations with Agentic AI
![skill]( "Hands On Experience")
- Detecting Prompt Injection and Jailbreak Risks
- LLM Integration with Gemini API
- Securing AI Data Against Poisoning Risks
- Tracking Model Provenance and Scanning Dependencies
- Ethical Screening using Sola Security
- Agentic AI for Cybersecurity Triage
![skill]( "skill you will learn")
- GenAI Security & Threat Analysis
- LLM Risk Assessment & Mitigation
- AI Pipeline & Data Security
- Ethical AI & Compliance Implementation
Agentic AI Course Description
What is covered in Edureka's Agentic AI Engineering Training Course?
Edureka’s Agentic AI Training Course is a live instructor-led certification program designed to help learners build, deploy, and monitor production-ready AI agents and autonomous AI systems.
The curriculum covers the complete modern agentic AI stack, including LangChain, LangGraph, CrewAI, MCP (Model Context Protocol), Agentic RAG, GraphRAG, DSPy, N8N workflow automation, FastAPI, Streamlit, Docker, AI observability, and LLM deployment.
What are the prerequisites for the Agentic AI Training Course?
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.
Who should take the Agentic AI Training Course?
This Agentic AI 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:
- Software Developers and AI Engineers
- Data Scientists and ML Engineers
- Solution Architects and Technical Leads
- Product Managers driving AI-powered automation initiatives
- Working professionals transitioning into AI engineering roles
Learners with a foundation in Python who want hands-on experience in modern AI engineering can also benefit from this course.
What is the duration of the Agentic AI Training Course?
The duration for this course is 60 hours along with self-paced modules which can be completed at your own preferred pace.
What are the learning outcomes of this Agentic AI Training?
After completing this agentic AI certification program, you will:
- Build intelligent AI workflows using LangChain, CrewAI, and multi-agent frameworks
- Develop autonomous AI agents that make decisions and solve problems independently
- Implement generative AI for content creation, automation, and knowledge work
- Design RAG (Retrieval-Augmented Generation) systems for enhanced AI accuracy and context awareness
- Deploy production-ready AI applications with proper monitoring, security, and scalability
- Automate complex business processes using AI-powered workflow orchestration and no-code/low-code automation platforms
- Master enterprise AI implementation best practices for real-world deployment
What are the key benefits of this Agentic AI Engineering Program?
The key benefits of this Agentic AI program are:
- Hands-on training with modern AI frameworks and tools
- Industry-relevant skills for AI engineer, AI architect, and AI specialist roles
- Practical projects building real-world agentic AI solutions
- Understanding of generative AI applications across industries
- Knowledge of autonomous agents, multi-agent systems, and AI orchestration
What tools and technologies does this course teach?
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
What is MCP and why is it taught in this course?
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.
What is DSPy and why is it included?
DSPy is a framework for programmatic prompt optimization. It replaces manual prompt engineering with measurable and self-improving prompt pipelines.
What does the N8N module teach?
The N8N module teaches workflow automation with triggers, APIs, webhooks, retries, scheduling, and integration with LangGraph-powered AI agents.
What does the course teach about Agentic RAG and GraphRAG?
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.
Who should take the Agentic AI Training Course?
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.
What are the system requirements for this course?
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.
What happens if I miss a live session?
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.
Agentic AI Engineering Projects
Build an AI-Powered Returns Triage Agent
Set up your full agent development environment and ship your first working autonomous agent for an online retailer. The agent ingests incoming return requests, classifies the ret....Build a Multi-Pattern Reasoning Agent for E-commerce Customer Inquiries
Build a reasoning agent for an online retailer that handles complex multi-part customer inquiries — comparing two products, explaining warranty against return policy, or planning....Build a Product Catalog Semantic Search Pipeline
Build an end-to-end semantic search pipeline for a fashion retailer's product catalog. You generate embeddings with OpenAI, store them in ChromaDB locally, then mirror the same d....Build a Retail Product Documentation Q&A Chain with LCEL
Build a complete LangChain document Q&A application for a consumer-electronics retailer that ingests product manuals, spec sheets, and warranty terms; splits and embeds them; and....Retail Market Intelligence Agent
Design a stateful research graph in LangGraph for a retail brand's market-intelligence team. The graph models the research flow with conditional edges that branch between competi....Build a Multi-Agent Travel Planning System
Build an end-to-end multi-agent travel planning system using the LangGraph supervisor pattern. A supervisor agent delegates work to specialist sub-agents — flights agent, hotels ....Retail Merchandising Crew
Build a CrewAI sequential crew for a retail merchandising team — three role-based agents (trend analyst, competitor research agent, content writer) collaborating to produce a wee....Build a Deep Media Trends Research Agent
Build an end-to-end deep research agent for a streaming-media analytics team. The agent decomposes a broad trend question ('what's driving genre rises this quarter') into a hiera....Build a Hybrid E-commerce Order Intelligence Pipeline with n8n
Build a hybrid pipeline that connects everything you've shipped to the real world. n8n handles the no-code automation layer — order webhooks, CRM updates, Slack notifications, em....E-commerce Customer Intelligence Platform
Architect, build, and deploy a multi-agent customer intelligence platform for an online retailer. The system ingests customer interactions, order history, browsing behaviour, and....Advanced Agentic AI Certification
The certificate is issued once a learner has completed all 20 live modules with and passed the final certification knowledge check.
The certificate validates production-grade competence across the agentic AI lifecycle — agent design and prompt engineering, agentic RAG, multi-agent orchestration with LangGraph and CrewAI, MCP tool integration, full-stack agent app development with FastAPI and Streamlit, AI safety and guardrails, observability with Langfuse and LangSmith, containerised deployment with Docker, and hybrid workflow automation with n8n.
No. The Edureka Agentic AI Engineer certificate has lifetime validity. As frameworks and tooling in the agentic AI space evolve rapidly, we recommend supplementing the certificate with continued practice and periodic refresher modules — Edureka alumni receive priority access to advanced courses and refreshers as new content is released.
John Doe
Title
with Grade X
XYZ123431st Jul 2024
The Certificate ID can be verified at www.edureka.co/verify to check the authenticity of this certificate
Zoom-in
reviews
Read learner testimonials
Earlier I had taken training in different technologies from other institutes and companies but no doubt Edureka is completely different, First time in my carrier I have received such kind of training and support. They have really awesome instructors. The support persons are technically sound and I would like to appreciate their 24 x 7 support. I never seen such kind of support by other companies in India till now. When I had started training on Hadoop I do not have any idea of Java but their training structure is marvelous and they taught Java in very easy way and build up confidence in it. My training is still going on and it is about to finish and I would like to thanks Edureka to help me to find robust path of carrier with such a new and emerging technology of Big Data.
December 09, 2017
The unique combination of Online Classes with 24*7 On-Demand Support and class recordings/ppt/docs etc in Learning Management System (LMS) on the site made me fall in love with edureka! There could not be a better Android Training Avenue to quench my thirst for learning Android Development.
December 09, 2017
Edureka has very good instructors and technical support team, I have completed the course BIG DATA & AWS through web training, and it was very good training, helped me to learn very swiftly. When I stuck up in installation and in writing map reduce programming technical support resolved very quickly and I was very happy with their response in time. As well as they providing life time access for our completed course videos so it will be useful in real time projects. I feel very happy to recommend Edureka for my friends on big data course.
December 09, 2017
Gagan Maheshwari
Thanks a lot for your Android course. Right from the point of the start of the demo class, until the end of the complete course, the ride has been truly joyous and full of learning . I had no insight into Android development but with the help of your excellent instructor, I now stand a chance to explore wider into this. The webinars were truly awesome. Live Online sessions were highly interactive. The edureka! methodology for Online classes has changed the way I look at webinars now. Plus point is the knowledgeable course material. I am falling short of words describing the great experience of my Android training at edureka!. Thanks Team edureka!
December 09, 2017
I have taken Informatica, Hadoop, R-programming, Spark and Scala and several other training's from past 3 years. There is no way to say that these courses are bad.. this is the exceptional institute with so many senior people who spend lot of their efforts for a cause. Because i know the pain as a trainer as well. Hats off to to team and the person who started edureka. I'm posting my personal experience and i do lot of social service. Good luck to others.
December 09, 2017
I am a Customer at Edureka. I attended the AWS Architect Certification Training, I found the training to be very informative. The course content was excellent, just what I was after. The trainer was very knowledgeable. I found him to be very patient, he listened and answered everyone's questions. I especially liked the way he repeated and summarised the previous day's leanings at the start of each new day. I also liked his interactive style of training. Edureka demonstrated the highest standard of professionalism in delivering the course content and their support to me in helping complete the project has been exceptional. Thanks Edureka!
December 09, 2017
Hear from our learners
Sriram GopalAgile Coach
Sriram speaks about his learning experience with Edureka and how our Hadoop training helped him execute his Big Data project efficiently.
Balasubramaniam MuthuswamyTechnical Program Manager
Our learner Balasubramaniam shares his Edureka learning experience and how our training helped him stay updated with evolving technologies.
Vinayak TalikotSenior Software Engineer
Vinayak shares his Edureka learning experience and how our Big Data training helped him achieve his dream career path.
Advanced Certification in Agentic AI Course FAQs
What is agentic AI and how does it differ from generative AI?
Agentic AI refers to autonomous systems that can reason, plan, use tools, retrieve knowledge, and act without human intervention. Unlike generative AI which creates content, agentic AI takes actions in the world through APIs, databases, and integrations. This course teaches you to build autonomous agents that solve real problems end-to-end.
Is LangChain required for agentic AI?
LangChain is the industry-standard framework for building agent applications and is core to this curriculum. However, agentic AI can also be implemented with LangGraph (advanced state management), CrewAI (multi-agent systems), or custom Python. This course covers LangChain deeply, then shows how to layer CrewAI and LangGraph for enterprise-scale systems.
What are the refunds and batch changes policy for this program?
You can withdraw and claim a refund at any time up to 48 hours after your batch’s first live class.
Refunds are paid less a processing fee of ₹1,500 (US$30 for international participants). After that period, no refund is payable.
Changing your batch: You can defer once to a later batch free of charge at any time before your batch begins. After it begins, you can change batch once in any three-month period, subject to seat availability, for ₹1,500 (US$30).
How to request: Write to learner.support@edureka.co from your registered email address. We will give you a decision within 7 working days, and process an approved refund within a further 7 working days. If you disagree with a decision, write to grievance@edureka.co and we will respond within 3 business days.
The terms that apply: The terms published here apply to your enrolment. If anything different has been described to you, please ask us to confirm it in writing before you enrol. Full terms are available on our Terms & Conditions page.
What is agentic RAG and why is it better than traditional RAG?
Agentic RAG (like CRAG and Self-RAG) iteratively improves retrieval quality by having the agent evaluate whether retrieved context is sufficient, and re-retrieve or rewrite queries if needed. Traditional RAG retrieves once and passes context to the LLM. Agentic RAG produces higher-quality answers by closing the loop — this course teaches both patterns in depth.
Can I learn multi-agent systems without prior agentic AI experience?
Yes. The first 6 modules establish agentic AI fundamentals, prompt engineering, embeddings, and LangChain basics. Modules 10–11 then teach CrewAI multi-agent orchestration, and modules 7–9 teach LangGraph multi-agent patterns. You do not need prior agentic AI experience, only working Python and comfort with APIs.
What is Model Context Protocol (MCP) and why is it important?
MCP is an emerging standard for tool interoperability between agents and backend systems. Instead of hardcoding API calls for each system, MCP allows agents to discover and invoke tools standardly. Modules 12–14 teach you to build custom MCP servers and integrate them into multi-agent pipelines — a critical skill for enterprise deployments.
How do I choose between LangGraph and CrewAI for multi-agent systems?
LangGraph excels at complex stateful workflows and long-horizon reasoning with checkpointing and human-in-the-loop. CrewAI excels at role-based agents with clear task dependencies and sequential execution. This course teaches both, and the capstone uses a hybrid approach — LangGraph for orchestration, CrewAI for crew-level collaboration.
What is prompt engineering for agentic systems and how is it different?
Agent prompt engineering focuses on eliciting reasoning (CoT, ToT, ReAct), structured outputs, and tool-use patterns. Module 2 teaches these patterns with real examples. Unlike static prompt engineering for text generation, agent prompts must guide autonomous decision-making across multiple steps and tool calls — a distinct skill.
Do I need to know Docker and Kubernetes before this course?
No prior Docker or Kubernetes experience is required. Module 18 teaches Docker fundamentals and containerisation of FastAPI agent services. The capstone uses Docker Compose for multi-service stacks. If you have DevOps experience, you will move quickly; if not, the course provides hands-on guidance.
What is NeMo Guardrails and when should I use it instead of Guardrails AI?
NeMo Guardrails (Colang-based) enforces topic and tone safety at the conversation level — best for controlling which subjects an agent engages with. Guardrails AI validates outputs with on-fail actions (reask, filter, exception) — best for ensuring structured outputs and avoiding PII leakage. Module 19 covers both patterns for different use cases.
How does observability with Langfuse and LangSmith help agentic systems?
Langfuse and LangSmith trace every agent step, token usage, and latency. You can evaluate agent quality, A/B test prompts, and cost-attribute per feature. For autonomous systems running in production, this visibility is critical — you need to know why an agent made a decision and where the cost is coming from. Module 16 and the capstone instrument full observability.
What is the difference between agentic AI and AI agents?
AI agents are software that perceive, decide, and act. Agentic AI refers specifically to autonomous systems powered by LLMs that can reason, plan, use tools, and retrieve knowledge at scale. This course focuses on agentic AI — using modern LLMs to build genuinely autonomous systems, not simple if-then bots.
Can I deploy agentic systems to production after this course?
Yes. Modules 15–18 teach full-stack deployment: FastAPI backends, Streamlit frontends, Docker containerisation, health checks, and observability. The capstone is a production-shaped system. You will not just learn patterns — you will ship a guarded, monitored, containerised agent to a Kubernetes cluster.
What is the salary range for agentic AI engineers in 2026?
India: ₹16–52 LPA depending on role and experience. US: $145K–$215K depending on seniority. Entry-level AI Agent Engineers start around ₹10 LPA (India) or $115K (US). Multi-agent systems engineers and architects command the higher bands. This course aims to position you in the mid-to-senior range within 12–24 months post-certification.
How do I prepare for an agentic AI engineer interview?
Be able to articulate why you would choose LangGraph over CrewAI for a given problem, explain agentic RAG vs traditional RAG, design a multi-agent system architecture on a whiteboard, and walk through a production deployment checklist. The capstone forces you to do all of this — completing it is the strongest interview preparation.
What is the difference between deep agents and simple agents?
Simple agents reason in 2–3 steps. Deep agents reason hierarchically, decomposing complex goals into subtasks, spawning sub-agents, and using memory hierarchies. Module 17 teaches deep reasoning patterns — essential for complex planning tasks like research, analysis, and multi-step workflows.
Is this course hands-on or lecture-heavy?
70% hands-on labs, 30% theory. Each live module includes a guided demo and a hands-on lab where you build alongside the instructor. You ship 14 projects, not watch 14 lectures. Every module assessment is a graded end-to-end project — theory is always paired with practice.
Can I use open-source LLMs like Llama instead of OpenAI?
Yes. The course defaults to OpenAI for consistency, but Ollama (Llama, Mistral) is integrated for local inference. Module 1 and the self-paced LLM Essentials cover model selection — cost-benefit of cloud APIs vs self-hosted models. You can adapt any project to your preferred model.
What are the prerequisites for the capstone project?
Completion of all 20 live modules and passing all module assessments. The capstone is a 15-hour integrated build that synthesises every skill from the course. It is mentor-reviewed on a 100-point rubric and defended in a live demo with the mentor.
How often are new batches of this course launched?
New batches start every 4–6 weeks to accommodate different schedules and time zones. Weekend batches (Saturday + Sunday, 8:30 PM to 11:30 PM IST) are the standard format. Cohort size is capped to ensure quality mentor and instructor attention.
Can employers sponsor employees for this course?
Yes. Edureka offers corporate enrolment packages with bulk discounts, completion tracking, and invoicing. Many organisations sponsor this course when scaling agentic AI systems internally. Contact the support team for a corporate proposal.
What happens if I fail the certification exam?
You are permitted two attempts. If both fail, additional mentor support and re-training modules are available at no extra cost. The cohort Discord and office hours support exam prep — most learners pass on the first or second attempt.
Is there a guarantee that I will get a job after completing this course?
No job guarantee, but the course is designed to make you highly hireable. A strong portfolio (14 projects), an industry-recognised certificate, and hands-on capstone experience are powerful hiring signals. Edureka's career services team helps with resume, LinkedIn, and mock interviews, but hiring is ultimately the responsibility of the employer.
How do I network with other learners?
The cohort Discord channel runs throughout the course with peer discussions, study groups, and trainer office hours. Edureka also hosts quarterly alumni events and maintains an alumni community for continued peer learning and career referrals.
Have more questions?
Course counsellors are available 24x7
For Career Assistance :
- Post Graduate Program in Generative AI and Agentic AI
- Doctor of Business Administration by Birchwood
- Integrated MS+PGP Program in Data Science & AI
- MS in Data Science by Birchwood
- European Global Doctorate of Business Administration (DBA)
- European Global MS in Data Science and AI
- EIMT Doctorate in Computer Science (DCS)