Courses Offered: SCJP SCWCD Design patterns EJB CORE JAVA AJAX Adv. Java XML STRUTS Web services SPRING HIBERNATE  

       

Full Stack Agentic AI Engineering Course Details
 

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

Batch Date: Apr 27th @7:00AM

Faculty: Mr. Maha (15+ Yrs of Exp,..)

Duration: 2 Months 15 Days

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 Hands On Projects

MODULE 1: Building the Foundation with Python, Data Handling, and Development Tools

Python Core Basics

  • Understand variables and data types.
  • Apply conditional statements and loops.
  • Write reusable functions.

Data Structures

  • Work with lists, including indexing, slicing, methods, and list comprehension.
  • Use dictionaries for key-value storage, including nested structures and iteration.
  • Understand tuples, immutability, and unpacking.
  • Perform string operations, including slicing, formatting, and common methods.

File Handling & JSON

  • Read and write files.
  • Parse and handle JSON data.

NumPy

  • Understand arrays and their advantages over lists.
  • Perform basic numerical operations.
  • Apply vectorized computations.

Pandas

  • Work with DataFrames and Series.
  • Perform data cleaning operations.
  • Filter and group data effectively.

Data Visualization

  • Create basic plots using Matplotlib.
  • Build interactive visualizations using Plotly.

Tools

  • Set up and manage virtual environments.
  • Install and manage packages using pip.
  • Use development tools such as Jupyter Notebook and VS Code.

Git

  • Understand Git fundamentals.
  • Use GitHub for version control and collaboration.

MODULE 2: Understanding AI, LLMs, and the Foundations of Agentic AI Systems

  • Understand the differences between AI, ML, DL, and NLP with real examples.
  • Learn the evolution from rule-based systems to Agentic AI.
  • Identify what makes an AI system “agentic.”
  • Explore real-world use cases such as automation, copilots, and assistants.
  • Understand tokens and tokenization.
  • Learn about context windows.
  • Understand embeddings and vector representations.
  • Learn the basics of transformer architecture and attention mechanisms.
  • Differentiate between training and inference.
  • Understand the need for frameworks in LLM applications.
  • Differentiate between chains, agents, and tools.
  • Framework : LangChain, LangGraph, LangSmith, Langfuse
  • Structure prompts using instructions, context, and expected output.
  • Control responses using temperature, max tokens, and top-p.

MODULE 3: Designing Agentic AI Architectures and Applying Design Patterns

  • Understand architecture types such as router, planner-executor, and supervisor-worker.
  • Learn perception, cognition, action, and security modules.
  • Apply reflection and self-critique patterns.
  • Implement tool-use patterns.
  • Apply planning patterns.
  • Use the ReAct framework.
  • Consider latency, cost, reliability, and auditability in design.
  • Design secure and scalable agent architectures.
  • Implement agent patterns correctly.
  • Build systems with predictable behavior.

MODULE 4: Building Production Pipelines Using LangChain and LCEL

  • Perform data ingestion using document loaders.
  • Apply effective text splitting strategies.
  • Use embeddings with vector databases.
  • Build pipelines using LCEL runnables, chains, and composition.
  • Generate structured outputs using schema-first JSON.
  • Ensure reliability through validation, retries, and fallbacks.
  • Deploy pipelines as API services.
  • Build composable pipelines using LCEL.
  • Extract reliable structured outputs.
  • Implement tool integration patterns.

MODULE 5: Developing Stateful AI Agents Using LangGraph with Memory

  • Understand LangGraph fundamentals.
  • Define state schemas and reducers.
  • Build branching graphs with checkpoints.
  • Implement human-in-the-loop approval gates.
  • Manage memory using short-term and long-term storage.
  • Deploy graph-based workflows.
  • Manage agent states effectively.
  • Implement human approval workflows.
  • Orchestrate reliable multi-step systems.

MODULE 6: Building Enterprise-Grade Agentic RAG Systems

  • Understand the difference between agentic RAG and traditional RAG.
  • Apply adaptive retrieval strategies.
  • Perform query rewriting and reranking.
  • Generate evidence-first answers with citations.
  • Measure groundedness, citation coverage, and retrieval recall.
  • Build robust RAG systems.
  • Improve retrieval quality through evaluation.
  • Reduce hallucinations using evidence constraints.

MODULE 7: Designing Knowledge Graphs for AI Systems Using Neo4j

  • Understand entity-relation modeling fundamentals.
  • Apply ontology-driven design.
  • Maintain provenance and audit trails in graphs.
  • Design constraints and schemas for AI systems.
  • Perform structured reasoning using relationships.
  • Model knowledge graphs for enterprise AI.
  • Improve explainability using graph traces.
  • Build governance-ready data representations.

MODULE 8: Implementing GraphRAG with Hybrid Retrieval Techniques

  • Perform graph traversal for multi-hop reasoning.
  • Combine vector, full-text, and graph retrieval methods.
  • Generate responses with evidence and reasoning paths.
  • Use relationship-aware retrieval for complex queries.
  • Design GraphRAG systems.
  • Implement hybrid retrieval strategies.
  • Enable explainable reasoning.

MODULE 9: Standardizing Tool Usage with MCP and Agent Tool Ecosystems

  • Understand MCP architecture and tool contracts.
  • Build MCP servers with standardized interfaces.
  • Implement secure tool access with read-only defaults.
  • Enable auditable tool execution.
  • Standardize tool access for agents.
  • Design secure tools.
  • Build extensible agent tooling.

MODULE 10: Building No-Code and Low-Code AI Agents Using n8n

  • Build workflows with triggers and approvals.
  • Integrate systems using webhooks, email, Slack/Teams, and databases.
  • Maintain audit logs and enterprise workflows.
  • Apply security considerations in automation.
  • Automate workflows using AI.

MODULE 11: Implementing Tooling and Safety Engineering with Guardrails

  • Understand threat models including prompt injection and unsafe tool calls.
  • Validate inputs and outputs.
  • Apply allowlists and view-only execution patterns.
  • Implement human approval workflows.
  • Build safe tool-using agents.
  • Design guardrails for production systems.
  • Enable approval-driven execution.

MODULE 12: Evaluating and Monitoring LLM Systems Using Observability Tools

  • Evaluate groundedness, citation coverage, and schema validity.
  • Apply judge-model evaluation patterns.
  • Use Langfuse for tracing and monitoring.
  • Track prompt versions.
  • Run experiments and comparisons.
  • Monitor cost and latency.
  • Evaluate agent reliability and correctness.
  • Instrument agents using Langfuse.
  • Conduct safe and repeatable experiments.

MODULE 13: Implementing Databricks Governance and Building Text-to-SQL Agents

  • Understand Unity Catalog fundamentals.
  • Apply views-only access patterns.
  • Generate schema-aware SQL queries.
  • Implement approval workflows before execution.
  • Store results in Delta and maintain run registries.
  • Build governed Text-to-SQL agents.
  • Generate schema-aware queries.
  • Ensure auditability and compliance.

Real-Time Projects

Project 1: Developing a GraphRAG Knowledge System

  • Ingest documents and extract entities to build a Neo4j provenance graph.
  • Implement hybrid retrieval using vector search combined with graph traversal.
  • Enable explainability by providing both supporting evidence and graph traversal paths.

Project 2: Creating a Multi-Agent Collaboration System

  • Implement supervisor-to-worker orchestration with retry mechanisms.
  • Integrate human approval workflows along with audit logging.
  • Enable governed tool usage using allowlists

Project 3: Building an MCP Tool-Augmented Agent

  • Build an MCP server that exposes secure, read-only tools using allowlists.
  • Implement structured tool outputs with governance patterns.
  • Ensure secure execution using least-privilege access and auditable processes.

Project 4: Developing a Databricks Ask-to-Query Agent

  • Build a Text-to-SQL coding agent using Genie-assisted workflows.
  • Inject schema details, including catalog, schema, table columns, and datatypes, into prompts.
  • Validate SQL queries using constraints such as SELECT-only operations, allowlisted views, and LIMIT clauses.
  • Implement an approval workflow to approve, edit, or reject queries before execution.
  • Execute approved queries and store results in Delta along with a run registry.

Project 5: Implementing LLM Evaluation and Observability

  • Instrument agent workflows using traces, spans, and runs.
  • Track prompt versions and conduct experiments for comparison.
  • Implement evaluation checks such as groundedness, citation coverage, and schema validity.
  • Monitor cost and latency, and build dashboards to ensure system reliability.