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

Batch Date: Aug 8th & 9th @7:30AM

Faculty: Mr. Siddharth Goutham (16+ Yrs of Exp,..)

Duration: 17 Weekends Batch

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:

Enterprise Advance AI Program Certification (EAAPC)
LLMs * RAG * Lang Graph * Multi Agent System's

PHASE 1: FOUNDATIONS OF LLMS & PROMPT ENGINEERING

Transformer Mechanics & Tokenomics

• Deep dive into the Transformer Architecture (Self-Attention, Encoder vs.
  Decoder models).
• Understanding Tokenization (BPE, WordPiece) and how context windows are consumed.
• LLM Pricing & Resource Calculations (Calculating cost per token, token throughput, and latency profiling).
• API Fundamentals: Setting up development environments and structuring robust API calls to OpenAI, Anthropic, and open-source models.
• Handling rate limits, connection timeouts, and implementing exponential backoff retry logic.

Enterprise Prompt Engineering

• Designing effective System Prompts and establishing clear persona configurations.
• Zero-Shot vs. Few-Shot learning: How to properly format context training data inside prompts.
• Chain-of-Thought (CoT) Prompting: Forcing step-by-step reasoning paths to increase complex logic accuracy.
• The ReAct (Reason + Action) Framework: The foundational loop that powers modern AI Agents.
• Structured Outputs (Part 1): Forcing LLMs to reply with strict, un-wrapped JSON formats.

Defending the Prompt & LangChain Introductions

• Structured Outputs (Part 2): Implementing Pydantic validation schemas to catch and correct bad model outputs.
• Prompt Injection Attacks: Understanding jailbreaking, indirect injection, and basic prompt validation defenses.
• Mitigating Hallucinations: Setting temperature boundaries and writing programmatic constraints.
• LangChain Ecosystem Overview: Installing core libraries and working with ChatModels .
• Dynamic Prompt Templates: Managing string manipulations, system messages, and user payloads at scale.
  

LangChain Expression Language (LCEL)

• LangChain OutputParsers: Utilizing built-in parsing filters to process strings into structured Python data models.
• LCEL Foundations: Mastering the pipe ( | ) operator to connect prompts, models, and parsers cleanly.
• Advanced LCEL: Implementing Runnable Parallel and Runnable Passthrough for simultaneous steps.
• Streaming Content: Building real-time token streaming pipelines across terminal interfaces.
• Building your first basic linear chain application (Input → Prompt → Model → Parser).

Context State & Tool Integration

• Introducing Memory: Using ConversationBufferMemory to keep state during multi-turn chats.
• Memory Budgets: Implementing sliding window memory (ConversationTokenBufferMemory ) to manage context usage.
• External Memory: Persisting conversation history in Redis or PostgreSQL databases.
• Creating Custom Tools: Converting standard Python functions into
  OpenAI-compatible tools using Pydantic parameters.
• LangChain Callbacks: Attaching runtime monitoring tools to inspect exact execution times and token counts.

PHASE 2: PRODUCTION RETRIEVAL-AUGMENTED GENERATION (RAG)

Document Ingestion Pipelines

• The RAG Architecture: Why simple models fail on proprietary enterprise data silos.
• Document Loaders: Extracting unstructured text cleanly from PDFs, Markdown, Word, and HTML.
• Naive Chunking vs. Recursive Character Chunking
  (Optimizing chunk sizes and overlaps).
• Advanced Chunking: Semantic Chunking based on token vector distances.
• Embedding Models: How text converts into vector space
  (Comparing OpenAI, Cohere, and open-source models).

Vector Storage Engineering

• Inside Vector Databases: Understanding coordinate spaces, cosine similarity, and Euclidean distance.
• Setting up Vector DBs: Working with ChromaDB (local) and Pinecone
  (cloud-native).
• Vector Indexes: Deep dive into Hierarchical Navigable Small World (HNSW) vs. Inverted File Index (IVF).
• Metadata Tagging: Building data extraction filters during the ingestion phase.
• Metadata Filtering: Querying vector indexes using exact property parameters to narrow search scopes.

Advanced Precision Search

• Keyword Search vs. Semantic Search: Why dense vectors fail on exact serial numbers or short IDs.
• Hybrid Search: Engineering a pipeline combining sparse keyword matching (BM25) + dense vector lookups.
• The Re-ranking Concept: Why retrieval volume (K=50) differs from prompt consumption budget (K=3).
• Implementing Cross-Encoder Re-rankers (Using Cohere Rerank or BGE-Reranker) to boost top results.
• Context Compression: Shrinking document chunks down to only the relevant sentences before building prompts.

Query Operations & RAG Evaluation

• Query Rewriting: Using an LLM to rephrase ambiguous user prompts into clear search parameters.
• Multi-Query Generation: Executing multiple search variations simultaneously to extract deeper context layers.
• Step-Back Prompting: Generating high-level, generalized concepts to extract broader contextual backgrounds.
• Sub-Query Decomposition: Breaking complex, multi-part user requests into individual data lookups.
• Introduction to RAG Evaluation: Why manual testing fails on large enterprise datasets.

RAG Hardening & Metrics

• Working with Ragas: Measuring Context Recall and Context Precision.
• Working with TruLens: Evaluating Faithfulness (Groundedness) and Answer Relevance.
• Building automated testing loops to benchmark chunking styles against evaluation datasets.
• Multi-Document RAG: Designing routing logic to query distinct vector indexes based on search intents.
• Production RAG Build: Finalizing a complete, optimized pipeline with hybrid search, re-ranking, and evaluations.

PHASE 3: STATEFUL MULTI-AGENT SYSTEMS WITH LANGGRAPH

Graph Architectures Foundations

• Why linear chains break: Understanding the need for loops, cyclical logic, and conditions.
• LangGraph Ecosystem: Core design principles, installing packages, and visual debugging layouts.
• Graph Components: Defining the global unified State dictionary.
• Graph Nodes: Building functional compute blocks that read and modify state attributes.
• Graph Edges: Implementing fixed navigation edges vs. Router-driven Conditional Edges.

Single-Agent Persistence

• Building a ReAct Agent entirely from scratch using LangGraph nodes and conditional tool edges.
• Memory Checkpointers: Using In-Memory checkpointers to save graph execution states automatically.
• Stateful Persistence: Storing graph snapshots inside SQLite or PostgreSQL backends for session saving.
• Code Self-Correction Loop (Part 1): Designing a graph where an agent writes code and runs it locally.
• Code Self-Correction Loop (Part 2): Capturing traceback errors, feeding them back to the agent node, and looping until tests pass.

Human-in-the-Loop Configurations

• Interrupting the Graph: Forcing breakpoints on sensitive nodes before critical tools run.
• State Editing: Manually altering the graph state variables during an active execution pause.
• Time Travel: Rewinding agent history, changing tool outputs, and re-running downstream graph nodes.
• Building an interactive user-approval interface for secure financial or data deletion tasks.
• Streaming Intermediate States: Showing users exactly what an agent is doing behind the scenes step-by-step.

Multi-Agent Teams Design

• Multi-Agent Theory: Dividing complex problems among specialized agents instead of using one massive model.
• Inter-Agent Communication: How discrete agents pass state variables and hand off control.
• The Collaborator-Supervisor Pattern: Building a lead router agent that delegates tasks to specialized sub-agents.
• Chord/Parallel Execution: Triggering multiple agent loops at once and merging their outputs into a main state.
• Hierarchical Agent Teams: Building independent sub-graphs that look like single tool nodes to a parent graph.

Production Multi-Agent System Build

• Use-Case Architecture: Designing a Research & Writing team
  (Planner → Researcher via RAG → Writer → Editor).
• Implementing the Core Loop: Setting up nodes for each persona and defining the evaluation criteria.
• Handling Edge Cases: Managing endless loop traps between a writer and editor agent.
• Hardening the Graph: Adding validation constraints and trace logging to every node.
• Review and Testing: Running stress tests across the graph to verify multi-turn consistency.

PHASE 4: NO-CODE AUTOMATION (N8N) & CODING AGENTS (CLAUDE CODE)

Enterprise Automation with n8n

• Introduction to n8n: Setting up a self-hosted Docker instance and exploring the node canvas.
• Webhooks and Triggers: Starting workflows automatically using API webhooks, schedule loops, and email arrivals.
• Data Routing in n8n: Using conditional expressions, switch nodes, and JavaScript data formatting.
• Advanced AI Nodes in n8n: Connecting OpenAI/Anthropic credentials directly into the workspace canvas.
• Ingestion Workflows: Building an automated n8n pipeline that watches Google Drive, chunks new files, and updates a vector database.
  

Production n8n Workflows & Claude Code

• Building Tool nodes inside n8n to fetch external live weather, market metrics, or CRM fields.
• Designing an automated support responder: Webhook received → RAG lookup → Slack alert → Draft email.
• Production n8n deployment: Handling error queues, logging steps, and optimizing high-volume setups.
• Introduction to Claude Code: Installing Anthropic's terminal agent and authorizing security access.
• Command-Line Basics: Navigating repositories, examining files, and using terminal agent command structures.

Codebase Autonomy with Claude Code

• Code Exploration: Letting Claude Code analyze a new repository to map file structures and dependencies.
• Multi-File Refactoring: Tasking the agent to update configurations or rewrite functions across multiple files simultaneously.
• Automated Testing: Using Claude Code to write test scripts, run them via the shell, and fix bugs based on errors.
• Git Integration: Running automated branch creations, commits, and pull request steps from the command line.
• Custom Configurations: Controlling agent behavior using claudecode and repo-level CLAUDE.md rule instructions.