Subcribe and Access : 5200+ FREE Videos and 21+ Subjects Like CRT, SoftSkills, JAVA, Hadoop, Microsoft .NET, Testin5g Tools etc..

Batch Date: Aug 3rd @7:30AM

Faculty: Mr. Vasanth (8+ Yrs of Exp,..)

Duration: 3 Months

Venue :
DURGA SOFTWARE SOLUTIONS,
Flat No : 202, 2nd Floor,
HUDA Maitrivanam,
Ameerpet, Hyderabad - 500038

Ph.No: +91 - 8885252627, 9246212143, 80 96 96 96 96

Syllabus:

AGENTIC AI Engineering
with GEN AI Foundations

Module 1: Generative AI & LLM Foundations (Days 1–8)

Objective: Understand how Large Language Models work, master prompt and context engineering, call LLM APIs, run open-source models locally, and build semantic search systems.

1.1 Introduction to Generative AI & the 2026 Model Landscape

• What is Generative AI? Generative vs Discriminative models
  · AI vs ML vs DL vs Gen AI
• AI landscape 2026: OpenAI, Anthropic, Google DeepMind, Meta, Mistral, DeepSeek
• Reasoning models vs chat models — when a single reasoning call replaces
  a multi-step chain
• Why Generative AI matters — real-world applications and business value

1.2 How LLMs Work

• Transformer architecture and attention mechanism — plain English explanation
• Tokens, context window, temperature, top-k, top-p sampling · tokenization and embeddings
• LLM families: GPT-4o/o-series, Claude, Gemini, LLaMA, Mistral, DeepSeek — model selection framework

1.3 LLM APIs, Prompt Engineering & Context Engineering

• Calling OpenAI and Anthropic APIs: system, user, assistant messages · streaming responses
• Multi-turn conversation state management in Python
• Prompt Engineering techniques:
  • Zero-shot, few-shot, and chain-of-thought (CoT) prompting · ReAct prompting
  • Tree-of-Thought (concept), persona-based, constraint-based, meta & negative prompting
• Context Engineering as a discipline — what goes in-context vs retrieved on demand, context sources, avoiding context poisoning and overload
• Structured outputs with JSON mode · evaluating LLM outputs
  

1.4 Open-Source LLMs & Local Deployment

• Open-source LLM families: LLaMA, Mistral, DeepSeek, Phi · open vs proprietary trade-offs
• Running models locally with Ollama — privacy and cost benefits
• Production serving awareness: vLLM, TGI and quantization (GPTQ/AWQ/GGUF) — what interviewers expect you to know

1.5 Embeddings & Vector Databases

• What are embeddings? Semantic similarity and cosine distance · embedding models (text-embedding-3, sentence-transformers)
• Vector databases: ChromaDB (dev), FAISS, Pinecone (managed), pgvector — the Postgres-native 2026 production default
• Indexing, similarity search, and metadata filtering
• Hands-on Project: Multi-turn chatbot using LLM API + Semantic document search engine

✦ Agentic AI in the Wild: Products powered by what you learn here: ChatGPT, Claude, Perplexity, DeepSeek — and why every one of them is racing on token efficiency.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ Earnings-Call Intelligence Engine — Q&A over real annual reports and earnings-call transcripts of listed companies, with streaming answers and semantic search.
✓ Enterprise Document Search — live ingestion of real filings and reports into a vector store with metadata-filtered retrieval.

Module 2: LangChain, Automation Chains & Retrieval-Augmented Generation (RAG) (Days 9–15)

Objective: Build end-to-end LLM automation pipelines and production-grade RAG systems with full evaluation and observability — positioned as the knowledge layer every agent calls.

2.1 LangChain Architecture & LCEL

• LangChain overview: LLMs, Chains, Prompts, Memory, Agents, Tools
• LangChain Expression Language (LCEL) — the modern pipeline syntax (legacy chain classes covered in one comparison slide)
• Conditional branching and dynamic routing pipelines · prompt templates
• Document Loaders and Text Splitters: preparing external knowledge for LLMs
• LlamaIndex introduction — query engines and when to choose it over LangChain

2.2 Agent Cognitive Layers, Memory & Structured Outputs

• Agent cognitive architecture: Perception → Memory → Decision → Action
  · Pydantic data contracts
• Memory types: Buffer, Summary, BufferWindow, VectorStoreRetriever
• Output parsers: Pydantic, JSON mode, schema-enforced outputs · Python logging for agents (DEBUG→CRITICAL)

2.3 Retrieval-Augmented Generation (RAG)

• Why RAG — the hallucination problem · architecture evolution: Naive → Advanced → Agentic RAG
• Document ingestion (PDF, web, CSV) · chunking strategies: fixed, semantic, recursive, parent-child
• Retrieval techniques: MMR, multi-query retriever, contextual compression
  (HyDE in brief)
• ReRanking with Cohere cross-encoders · hybrid planning: heuristics + LLM decision matrix
• Function calling & tool use: OpenAI tools schema, Anthropic tool_use

2.4 RAG Evaluation & Observability

• RAGAS framework: Answer Relevance, Context Precision, Faithfulness, Answer Correctness
• LangSmith: end-to-end tracing, cost tracking, latency profiling
• Langfuse: the open-source enterprise alternative — traces, spans, prompt versioning, experiments
• Evaluation-driven iteration: building a ground-truth dataset and fixing failing pipelines
• Hands-on Project: Full RAG chatbot with source citations, RAGAS evaluation scores, and LangSmith/Langfuse observability

✦ Agentic AI in the Wild: Every enterprise copilot (Microsok 365 Copilot, Glean, Notion AI) is a RAG system underneath — you will know how to evaluate whether theirs is any good.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ Regulatory Compliance Copilot — RAG over real RBI/SEBI circulars with citations, reranked retrieval and RAGAS audit scores — the pipeline banks and fintechs audit before go-live.

Module 2.5: Knowledge Graphs & Agentic GraphRAG (Neo4j)
(Days 16–18)

Objective: Design enterprise knowledge graphs with Neo4j and build GraphRAG as an agent tool — combining vector search with graph traversal for multi-hop reasoning and explainable answers.

2.5.1 Knowledge Graph Fundamentals

• Why knowledge graphs — when vector search alone fails · entity-relation modeling: nodes, edges, properties
• Ontology-driven design, schema constraints, provenance and audit trails · Neo4j Cypher basics

2.5.2 Agentic GraphRAG — Hybrid Retrieval

• GraphRAG vs traditional RAG · multi-hop graph traversal ("Who approved this contract, what team do they manage, what policy governs it?")
• Hybrid retrieval: vector + full-text + graph traversal · "show evidence + show path" explainable answers
• Evaluation: groundedness, citation coverage, retrieval recall
• Hands-on Project: GraphRAG agent — ingest documents, extract entities to Neo4j, hybrid retrieval with explainable evidence + graph path

✦ Agentic AI in the Wild: LinkedIn, BlackRock and major pharma companies run GraphRAG in production for exactly these multi-hop compliance questions.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ Vendor-Risk & Contract Intelligence Graph — who approved this vendor, what policy governs them, which contracts are exposed — multi-hop Neo4j traversal with an explainable reasoning path.

Module 3: Agentic AI Foundations, Design Patterns & Single-Agent Systems (Days 19–30)

Objective: Master the core building blocks, design patterns and memory architecture of autonomous agents; build production single-agent systems across LangGraph, OpenAI Agents SDK and provider-native SDKs. First working agent by Day 19.

3.1 Introduction to Agentic AI

• What is Agentic AI? Agent vs Chain — the key distinction · autonomous decision-making vs traditional software
• Core building blocks: Perception, Cognition/Reasoning, Planning, Action, Memory, Adaptability
• Agent anatomy: the Perception → Reasoning → Action loop · LLM as brain, tools as hands, memory as context

3.2 Agent Design Patterns

• ReAct — Thought → Action → Observation loop · Reflection — agents that critique and improve their own outputs
• Reflexion — self-improvement loops via trial and error
• Tool Use — structured calling, error handling, max-iteration safety · Planning — Plan-and-Execute, ReWOO (ToT conceptual)
• Human-in-the-Loop (HITL): when and how to add human oversight · hybrid rule + LLM planning

3.3 Frameworks — LangChain Agents & LangGraph

• ReAct agents with LangChain AgentExecutor · real tools: Tavily web search, calculator, database
• LangGraph: stateful workflows — graph nodes, edges, TypedDict state · DAG execution, fallback nodes, parallel variants
• Human-in-the-loop in LangGraph: interrupt_before, checkpointers (SQLite/Postgres), workflow resumption

3.4 Agent Memory — the 2026 First-Class Architecture Layer

• Why context windows are not memory · short-term vs long-term vs semantic memory tiers
• Memory frameworks: Mem0, Zep, LangMem, Letta — extraction, retrieval, expiry policies
• Token-efficient memory & context compression — shrinking tokens while preserving fidelity (the biggest cost lever in agent design)
  

3.5 Provider SDKs

• OpenAI Agents SDK: Agents, Handoffs, Guardrails, Tracing · streaming multi-step agents · vs LangChain AgentExecutor
• Claude Agent SDK & Google ADK overview — the provider-native SDK wave; SDK vs framework vs raw code decisions
• Hands-on Project: Research Agent (ReAct + OpenAI SDK) and SRE Incident-Triage Agent with human approval gate (LangGraph)

✦ Agentic AI in the Wild: Devin, Claude Code, and OpenAI Deep Research are all built from the exact patterns in this module — ReAct loops + tools + memory + HITL.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ Live Research Agent — autonomous web research on real-time search data with safe-termination logic.
✓ SRE Incident-Triage Agent — reads real log and alert streams, classifies severity, diagnoses root cause and drafts remediation — a human approves/edits/rejects before any action executes.
✓ Persistent Memory Agent — an operations assistant that remembers engineers, systems and past incidents across sessions using Mem0-style extraction.

Module 4: Multi-Agent Systems, MCP, A2A & Agentic Automation (Days 31–43)

Objective: Build production-grade multi-agent systems with CrewAI and AutoGen; master MCP for agent-to-tool and A2A for agent-to-agent interoperability; ship no-code agent automations with n8n. This module is the heart of the course.

4.1 Multi-Agent Systems & CrewAI

• Why multiple agents — specialisation, parallelism, fault isolation · patterns: broadcast, blackboard, supervisor, swarm
• Orchestrator vs subagent roles · inter-agent memory sharing and context passing
• CrewAI: Agents, Tasks, Tools, Crews · sequential / hierarchical / parallel processes · roles, goals, backstories · CrewAI Flows
• Hands-on: 3-agent Content Pipeline (Researcher + Writer + Editor) · Stock Picker Agent on live market data

4.2 AutoGen — Conversational Multi-Agent & Code Agents

• ConversableAgent, AssistantAgent, UserProxy · GroupChat and GroupChatManager
• Code-execution agents in Docker sandbox · Agent Factory pattern for reusable blueprints
• Hands-on: 4-agent Engineering Team — PM + Developer + Tester + Reviewer

4.3 Browser, Computer-Use & Deep Research Agents

• Browser automation agents with Playwright · OpenAI Operator & Anthropic computer-use concepts
• The Deep Research pattern — multi-agent research teams, the defining 2026 use case

4.4 Model Context Protocol (MCP) — Deep Dive (2 full days)

• MCP architecture: server, client, tool schema standardisation · building an MCP server hands-on
• MCP Inspector debugging (STDIO vs HTTP transports) · Claude Desktop as an MCP client — real Windows configuration
• Multi-server MCP platforms: multiple department servers consumed by multiple client frameworks simultaneously

4.5 A2A Protocol — Agent-to-Agent Communication

• A2A (Google → Linux Foundation standard): Agent Cards, client-server model, task lifecycle, authentication · MCP vs A2A
• Hands-on: two agents on different frameworks communicating via A2A

4.6 No-Code Agentic Automation — n8n (2 days)

• Visual workflow builder, AI nodes, triggers · integrations: Gmail, Sheets, Slack, Calendar, webhooks
• Email triage workflow: classify → respond → log
• Telegram AI-agent bots — webhooks, ngrok tunnelling, Telegram Trigger, AI Agent node with tools & memory · cloud deployment of workflows

✦ Agentic AI in the Wild: Salesforce AgenVorce, ServiceNow AI Agents and SAP Joule are all beṄng on MCP + A2A — the exact protocol stack you master here.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ District AI Platform — 3 department MCP servers (Health, Agriculture, Alerts) on real public data, consumed by 4 client frameworks — LangGraph, AutoGen, n8n and Claude Desktop — a genuine enterprise multi-server architecture.
✓ Stock Picker Crew — CrewAI agents researching and analysing live market data to produce investment recommendations.
✓ Autonomous DevOps War Room — Monitor + Diagnoser + Remediator + Comms agents handling an incident end-to-end in a Docker sandbox — the AutoGen 4-agent pattern applied to operations.
✓ Field-Ops Alerts Bot (Telegram) — real-time alerts pushed to on-ground teams: webhook triggers, AI Agent node with memory, deployed from laptop (ngrok) to cloud..

Module 5 : Responsible AI, Security & Agent Evaluation (Days 44–48)

Objective: Implement enterprise-grade evaluation pipelines, threat-model production agents, and translate responsible-AI principles into working guardrail code.

5.1 Agent Evaluation & Observability

• RAGAS deep evaluation · LangSmith agent tracing · AgentOps cost dashboards, token budgets, latency profiling
• DeepEval with CI gates (deepeval test run) — evaluation as part of the build pipeline
• Custom deterministic domain metrics — tool success rate, latency P95, fallback rate, false-negative penalties — built on a real ground-truth scenario dataset
• Prompt versioning and registry · evaluation-driven iteration

5.2 Ethics, Governance & the EU AI Act

• Bias and fairness: detection and mitigation · transparency, explainability, accountability
• EU AI Act risk tiers — now in enforcement (August 2026): obligations for high-risk agent systems · who is responsible when an agent fails?

5.3 Security Threat Modeling for AI Agents

• The 4 attack surfaces: prompt injection, indirect prompt injection, unsafe tool calls, data exfiltration — real attack walkthroughs
• Defence patterns: input sanitisation, allowlist/read-only tools, views-only execution, approval gates, least privilege, auditable tool logs
• Red-teaming your agents before production release

5.4 Technical Guardrails

• Guardrails AI and NeMo Guardrails: input/output validation, topical and safety rails
• PII detection and masking · hallucination detection and factual grounding · OpenAI Agents SDK built-in guardrails

✦ Agentic AI in the Wild: Eval design is called the hardest agent skill to fake in 2026 hiring — this module is your interview superpower.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ CI-Gated Evaluation Harness — a real 10-scenario ground-truth dataset, 11 deterministic metrics, RAGAS + DeepEval, wired into the build pipeline — evaluation depth almost no other course teaches.
✓ SOC-Style Red-Team Harness — students attack their own agents with real prompt-injection payloads, then engineer and verify the defences — security-operations methodology.

Module 6: Production Deployment, Agent MLOps & LLM Engineering Essentials (Days 49–57)

Objective: Ship agents to real cloud endpoints with security and observability, control cost at scale, and gain the LLM-engineering fluency (fine-tuning, serving, cloud AI services) interviewers expect.

6.1 Serving Agents — APIs, UIs & Containers

• FastAPI: agents as REST endpoints · API gateway pattern in front of multiple agent services
• .env files, secrets, API-key security · Docker containerisation (Kubernetes vs Cloud Run — when each fits, in brief)
• Streamlit & Gradio agent UIs · HITL approve/edit/reject interface patterns

6.2 Cloud Deployment

• HuggingFace Spaces (portfolio-ready) · Render / Railway (simple backends)
• GCP Cloud Run production deployment: one Dockerfile + one command per service · Secret Manager · progressive security: API keys → IAM Service Accounts → Firebase JWT
• Cloud AI services map: AWS Bedrock, Google Vertex AI, Azure OpenAI — what each is for

6.3 Observability & Cost Optimisation at Scale

• Full-stack observability: OpenTelemetry for agents, Cloud Trace/Monitoring, AgentOps + LangSmith together
• Semantic caching · native prompt caching (Anthropic/OpenAI) · LLM routing: strong vs fast model by query complexity
• Token shrinking & context compression in production — cutting cost without cutting quality
• Agent MLOps: CI/CD with GitHub Actions · A/B testing agents · drift detection · experiment tracking awareness (MLflow / W&B)

6.4 LLM Engineering Essentials — Interview-Ready Fluency

• Fine-tuning vs RAG vs Prompting — the decision framework every JD tests
• Guided LoRA fine-tuning demo on free Google Colab (HuggingFace PEFT) — no local GPU needed
• Awareness: Semantic Kernel, RLHF/DPO concepts — know the names, know when they are used

6.5 Voice & Event-Driven Agents (Overview + Demo)

• Voice agents: STT → LLM → TTS pipeline, realtime APIs · where they are deployed (support, sales)
  Event-driven and streaming agents — agents that act on live data, not just prompts

✦ Agentic AI in the Wild: Trending now: Manus, Devin 2.0, GitHub Copilot agents, ElevenLabs voice agents — by this module you can explain how each is architected.

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ SRE-Grade Production Deployment — a real Cloud Run endpoint with Secret Manager, JWT auth and OpenTelemetry traces — an observability stack an SRE would sign off on.
✓ Cost-Optimised Agent — the same agent before/after prompt caching, routing and context compression
— with measured cost savings.

Module 7: Capstone Projects & The Future of Agentic AI (Days 58–65)

Objective: Build and present an end-to-end, production-grade agentic system with evaluation scores and a live deployment; leave with a porVolio, an interview story, and a career roadmap.

7.1 Capstone Projects (choose one of five)

• Intelligent Document Assistant — multi-format RAG, Streamlit UI, citations, ReAct agent
• Autonomous Research Reporter — CrewAI multi-agent: Researcher + Analyst + Writer
• AI Workflow Automation Bot — LangGraph agent with human approvals, MCP + A2A
• 4-Agent Engineering Team — AutoGen crew: PM + Developer + Tester + Reviewer
• Domain Expert Agent — RAG + tools in HR, finance, legal or healthcare, with guardrails
• Deliverables: working demo at a live URL, RAGAS/DeepEval scores, architecture doc, GitHub repo, 5-minute presentation
• Structure: kickoff & architecture review → guided build days with checkpoints → evaluation & deployment → two presentation days

7.2 Future of Agentic AI & Your Career

• Where Agentic AI is heading: reactive → proactive → autonomous organisations · the protocol stack: MCP * A2A → what comes next
• Career pathways: Agentic AI Engineer, AI Engineer, MLOps/AI DevOps, AI roduct Manager, AI Solutions Architect — mapped to real 2026 job descriptions
• Resume and interview guidance: presenting your capstone with eval rigor · skills that stay relevant vs what gets automated
• AGI — honest 10-minute framing · Course 2 roadmap: Agentic AI in Production & MLOps Engineering

⚙ Real-World Agents Covered in Class (real data · real deployments)
✓ Your Own Deployed Capstone — every student graduates with a live URL, measurable evaluation scores, and a GitHub repository — a portfolio piece, not a certificate alone.