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

Batch Date: June 1st @10:00PM

Faculty: Mr. Krishna (14+ 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:

Full Stack Agentic AI Engineering
Build & Deploy Production Level AI Agents
with Python & Hands On Projects

MODULE 1: Generative AI & LLM Foundations

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

1.1 Introduction to Generative AI

• What is Generative AI?
  • AI Frameworks : OpenAI, Anthropic, Google DeepMind, Meta, Groq. AWS Bedrock
  • Chat Models. Messages, Multi-query, Streamlit Python UI
  • Why Generative AI matters — real-world applications and business value
  • Generative AI vs Agentic AI

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 — foundational overview
  • LLMs: GPT-4o, Claude, Gemini, LLaMA 3, Groq, DeepSeek
  • Open-source vs proprietary models — model selection framework

1.3 LLM APIs & Prompt Engineering

• Calling OpenAI and Anthropic APIs: system, user, assistant messages
  • Multi-turn conversation state management in Python
  • Prompt Engineering techniques:
    • Zero-shot, few-shot, and chain-of-thought (CoT) prompting
    • ReAct prompting: Reason + Act pattern
    • Tree-of-Thought (ToT), persona-based, constraint-based prompting
  • Context Engineering: system prompt design, goal framing, constraint embedding
  • Evaluating LLM outputs — quality metrics and best practices

1.4 Open-Source LLMs & Local Deployment

• Open-source LLM families: LLaMA 3, Groq, DeepSeek,HuggingFace
  • Running models locally with Ollama — privacy and cost benefits

1.5 Embeddings & Vector Databases

• What are embeddings?
  • Embedding models: OpenAI text-embedding-3, HuggingFace embeddings
  • Vector databases:
    • ChromaDB — local vector store for development
    • FAISS — Facebook AI Similarity Search
    • Pinecone — managed vector database for production
    • RagStack
  • Indexing, similarity search, and metadata filtering
  • Hands-on project: semantic document search engine
  • Hands-on Project: Multi-turn chatbot using LLM API + Semantic document search engine

MODULE 2: LLM Automation, Chains & Retrieval-Augmented Generation (RAG)

Objective: Build end-to-end LLM automation pipelines and production-grade RAG systems with full evaluation.

2.1 LangChain Architecture

• LangChain overview: LLMs, Chains, Prompts, Memory, Agents, Tools
  • Chain types:
    • LLMChain, QnA chain
    • ConversationChain
  • Prompt Templates: Standard, Few-shot, Zero-shot, and Custom templates
  • Document Loaders and Text Splitters: preparing external knowledge for LLMs

2.2 Agent Cognitive Layers & Memory

• Agent cognitive architecture: Perception → Memory → Decision → Action
  • Pydantic data contracts between cognitive modules
  • Memory types:
    • short-tem memory
    • long-term-memory
  • Output parsers: Pydantic, JSON mode, structured schema-enforced outputs

2.3 Retrieval-Augmented Generation (RAG)

• What is RAG and why it is needed — the hallucination problem
  • RAG architecture: RAG → Agentic RAG
  • Components of RAG:
    • Document ingestion: PDF, web, CSV, Text files
    • Chunking strategies: fixed-size, semantic, recursive
    • Vector Database (FAISS, Pinecone, ChromaDB. Ragstack)
    • LLM integration for answering queries
  • Retrieval techniques:
    • Maximum Marginal Relevance (MMR)
    • Multi-query retriever
    • Contextual compression
    • HyDE — Hypothetical Document Embeddings
  • ReRanking with Cohere cross-encoders
  • Document Reordering
  • Function calling and Tool use: OpenAI tools schema, Anthropic tool_use
  • Applications of RAG: chatbots, search, knowledge assistants, enterprise Q&A;
  • Workflow of RAG — step-by-step explanation

2.4 RAG Evaluation & Observability

• RAGAS evaluation framework:
  • Answer Relevance
  • Context Precision
  • Faithfulness
  • Answer Correctness
• LangSmith: end-to-end pipeline tracing, cost tracking, latency profiling
• Evaluation-driven iteration: diagnosing and fixing failing RAG pipelines
• Hands-on Project: Full RAG chatbot with source citations, RAGAS evaluation scores, and LangSmith observability

2.5: Knowledge Graphs & GraphRAG (Neo4j)

Objective: Understand enterprise knowledge graph design with Neo4j and build GraphRAG systems that combine vector search with graph traversal for complex multi-hop reasoning.

MODULE 3: Agentic AI Foundations & Design Patterns

Objective: Understand the core building blocks and architectural patterns of autonomous AI agents and build single-agent systems using multiple frameworks.

3.1 Introduction to Agentic AI

• What is Agentic AI? Agent vs Chain — the key distinction
  • Core AI agent building blocks: Perception, Cognition/Reasoning, Planning, Action, Memory, Adaptability & Learning
  • Agent anatomy: Perception → Reasoning → Action loop
  • LLM as the brain, tools as hands, memory as context

3.2 Agentic AI Architectures & Design Patterns

• Architectural concepts: single-agent, multi-agent, hierarchical, swarm
  • Key Design Patterns:
    • ReAct — Reason + Act pattern: Thought → Action →Observation loop
    • Reflection — agents that critique and self-improve their own outputs
    • Tool Use — structured tool calling,
    • Planning — Plan-and-Execute
  • Human-in-the-Loop (HITL): when and how to add human oversight

3.3 Practical Agent Development & Deployment

• Building agents with langgraph
  • Tools and APIs integration
  • Context Engineering for agents: system prompt design and goal framing
  • Agent reliability: max iterations, fallback strategies, safe termination
  • An HR Assistant Agent checks the weather using check_weather and decides whether employees should work from home or come to office.

Then it sends the final update email using send_email and confirms the To, CC, and Subject details (LangGraph,Human-in-loop)

MODULE 4: Multi-Agent Systems, and Frameworks

Objective: Build production-grade multi-agent systems using Lnggraph, CrewAI, Agno, and langflow. Implement A2A protocol for cross-framework agent interoperability.

4.1 Multi-Agent Systems

• Why multiple agents? Specialisation, parallelism, and fault isolation
  • Communication patterns: broadcast, blackboard, supervisor, swarm
  • Orchestrator vs subagent roles and responsibilities
  • Inter-agent memory sharing and context passing

CrewAI & Multi-Agent Systems

• CrewAI architecture: Agents, Tasks, Tools, Crews
  • Process types: sequential, hierarchical, parallel
  • Designing agent roles, goals, and backstories
  • CrewAI Flows: event-driven orchestration and multi-crew state management
  • Hands-on projects:
    • 3-agent Content Pipeline: Researcher + Writer + Editor
    • Stock Picker Agent: research, analyse, and recommend investments

4.2 Agno - Agentic framework

• AutoGen architecture: ConversableAgent, AssistantAgent, UserProxy
  • Agno is a high-performance runtime for multi-agent systems.
  • It helps you build, run, and manage secure multi-agent systems in your own cloud.
    

Agents

• Build simple autonomous agents that can understand a task, decide the next step, and take action.

Session Management

• Learn how agents continue from where the user stopped, like Netflix resumes a movie from the paused point.

Memory

• Learn how agents remember past conversations and use that context in future chats.

Knowledge

• Learn how agents use documents, facts, or company data to answer questions accurately.

Human-in-the-Loop

• Learn how humans can review, guide, approve, or reject important agent actions.

MCP Server

• Learn how Model Context Protocol (MCP) helps agents connect with external tools and applications using a common standard.

Teams / Multi-Agent Systems

• Build multiple agents that work together as a team, where each agent has a specific role.

Workflows

• Automate complex workflows using Agentic AI, tools, memory, and approval steps.

4.3 LangGraph - Agentic framework

TypedDict

• Learn how to define a dictionary with fixed keys and fixed data types for graph state.

State

• Understand state as the shared memory that moves through the graphe.

Node

• Learn how each node works as one function or one step in the workflow

Edge

• Understand how edges define the execution order between nodes.

START

• Learn how START defines the entry point of the graph.

END

• Learn how END defines the exit point of the graph.

Compile

• Learn how to compile the graph and make it runnable

StateGraph

• Understand StateGraph as a flow controller that passes state through different nodes.

AI Assistant with Tools

• Build an AI assistant or chatbot using tools like Wikipedia, Arxiv, DuckDuckGo, and Tavily.

Basic Chatbot with Memory and Streaming

• Build a chatbot that remembers conversation history and streams responses in real time

Agent with Custom Tools

• Build an agent using custom tools, such as adding two numbers, along with search tools like Tavily.

Human-in-the-Loop

• Add human approval or review steps before the agent takes important actions.

Supervisor-Based Multi-Agent System

• Build a supervisor agent that manages multiple specialized agents and routes tasks to the right agent

Live Project: Insurance Claims Validation Automation

• Build an Agentic AI system that validates insurance claims using documents, tools, memory, human approval, and workflow automation.

4.3 No-Code/Low-Code Agent Development

• LLM aplication RAG pipeline with no code frmawork langflow

MODULE 5: Responsible AI & Evaluation

Objective: Understand ethical principles and safety frameworks for AI systems. Implement observability and evaluation pipelines. Apply technical guardrails in production agents.

5.1 AI and Evaluation

• Observability and evaluation:

5.2 Security Threat Modeling for AI Agents

• Threat model for production agents: the 4 main attack surfaces
  • Prompt injection: malicious instructions injected via user input or retrieved documents
  • Indirect prompt injection: attacker-controlled content in the agent's context window
  • Unsafe tool calls: agent tricked into executing destructive or unintended actions
  • Data exfiltration: agent leaking sensitive retrieved content to untrusted endpoints
• Architectural defence patterns:
  • Input sanitisation and allowlist-based tool access (read-only by default)
  • Views-only execution patterns: never query base tables or execute write operations without approval
  • Human approval gates: approve / edit / reject before agent executes high-risk actions
  • Least-privilege tool design: agents get minimum permissions required
  • Auditable tool execution: every tool call logged with inputs, outputs, timestamps
• Prompt injection: definition, real attack examples, and step-by-step defence strategies
• Adversarial prompting and jailbreak attempts — patterns and mitigations
• Security testing: red-teaming your agents before production release

5.3 Technical Guardrails Implementation

• Guardrails AI: input and output validation, topic rails
  • NeMo Guardrails: conversation flows, topical rails, safety rails
  • PII (Personally Identifiable Information) detection and masking
  • Hallucination detection and factual grounding
  • OpenAI Agents SDK guardrails: built-in safety parameters
  • From ethics to code: translating responsible AI principles into guardrail design

MODULE 6: Production Deployment & MLOps

Objective: Instrument AI agent systems for production, deploy to live endpoints, and understand the MLOps landscape.

6.1 Practical Agent Deployment

• Building agents with Python, Tools, and APIs
• LangServe API
  • FastAPI: wrapping agents as REST API endpoints
  • Environment management: .env files, secrets, API key security
  • Cloud deployment:
    • HuggingFace Spaces — free, portfolio-ready deployment
    • Render / Railway — simple backend deployment
  • Streamlit : building agent UIs for demos and production

6.2 Model Context Protocol (MCP)

• What is MCP? Anthropic's open standard for agent-to-tool communication
  • MCP architecture: MCP server, MCP client, tool schema standardisation
  • Building an MCP server hands-on: exposing tools via MCP
  • MCP + A2A together: complete protocol stack for enterprise agents

7. Interview Questions and answers

• Interview Questions and Answers (Mock Interview Questions)

8. Python Basics Essential for GenAI and Agentic AI

• Python fundamentals
• Variables and data types
• Conditional statements
• Loops
• Functions
• Function calling
• Classes and objects
• Lists, tuples, dictionaries, and sets
• File handling basics
• Exception handling
• Basic problem-solving programs
• Sample programs for GenAI and Agentic AI use cases

8. Live Project Flow: Advanced RAG Chatbot

In this project, we will build a smart RAG chatbot that answers questions from documents with better speed, safety, and accuracy.

1. Cache Check

First, the system checks if the same question was already answered before.
If yes, it returns the saved answer quickly.

Use: Saves time and cost.

2. Prompt Injection Check

The system checks whether the user question contains unsafe or harmful instructions.
If the query is risky, the chatbot stops and shows a warning.

Use: Protects the chatbot from misuse.

3. Multi-Query Generation

The system converts one question into multiple related questions to search better.

Example:
Original question: Explain blockchain technology

Generated Questions:

• How does blockchain work?
• What are the benefits of blockchain?
• How is blockchain used in finance?

Use: Finds more relevant information.

4. Retrieval (Azure AI Search Vector Database)

The system searches relevant document chunks from the Azure AI Search vector database using embeddings.

Use: Retrieves the best matching content from company/private documents.

5. Contextual Compression Retrieval

The retrieved content is filtered and compressed.
Only the most useful parts are kept before sending to the LLM.

Use: Improves accuracy and reduces token usage.

6. Document Reordering

The selected content is arranged based on importance.
The most relevant information is sent first to the LLM.

Use: Helps the model focus on the best context.

7. Generate Final Answer

The LLM uses the selected context and generates a clear final answer for the user.

Use: Gives accurate and easy-to-understand responses.

Final Outcome

We will build an Advanced RAG Chatbot with:

Cache + Security Check + Multi-Query Search + Azure AI Search Vector Database + Context Compression + Reordering + Final Answer Generation.

Final Course Outcomes

After completing this course, learners will be able to:

• Understand Agentic AI, Generative AI and LLM fundamentals
• Build chatbots using OpenAI, Claude, Gemini, Groq, and open-source models
• Work with prompt engineering and context engineering
• Build semantic search systems using embeddings and vector databases
• Build RAG applications using LangChain
• Evaluate RAG systems using RAGAS and LangSmith
• Understand Agentic AI architecture and design patterns
• Build agents using LangGraph and Agno
• Build multi-agent systems using CrewAI and Agno
• Use MCP for agent-to-tool communication
• Build low-code RAG workflows using LangFlow
• Apply Responsible AI, security checks, and guardrails
• Deploy AI apps using FastAPI, LangServe, Streamlit, Gradio, HuggingFace Spaces, Render, or Railway
• Build live projects and prepare for GenAI / Agentic AI interviews