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

Batch Date: Nov 19th @8:00PM

Faculty: Mr. Venky (5+ Yrs of Exp,..)

Duration : 3.5 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:

Python-Based Generative AI & Agentic AI Engineering

Part I: Core Python Foundation for AI & Systems Engineering

Modules 1 to 6 • Computational logic, functional constructs, OOP, backend utilities, and scientific AI libraries

Module 1: Python Fundamentals

1. Introduction to Python, installation, VS Code setup, first program, print()
2. Variables, primitive data types, type casting, interactive input via input()
3. Operators: arithmetic, comparison, logical, assignment, identity & membership
4. Conditional decision branching: if, elif, else, and nested conditions
5. Loops: for, while, execution flow control with break, continue, and pass

Practical Exercises: Student Marks Calculator • Electricity Bill Calculator • ATM Withdrawal Simulation

Module 2: Python Data Structures

6. Strings: indexing, slicing, immutability, formatting, and string transformation methods
7. Lists: dynamic arrays, indexing, slicing, mutability, and essential list manipulation methods
8. Tuples and Sets: immutable sequences, unique element hashing, and set algebra operations
9. Dictionaries: key-value storage, lookup performance, nested dictionary structures
10. Comprehensions: list comprehension, dictionary comprehension, and custom key sorting

Real-Time Practicals: Employee Records Management • E-Commerce Shopping Cart Implementation

Module 3: Functions and Advanced Python

11. Functions: definitions, scopes, parameter passing, return structures, docstrings
12. Argument patterns: default, keyword, positional, dynamic packing via *args and **kwargs
13. Functional programming: anonymous functions (lambda), map, filter, reduce
14. Modular design: importing modules, writing custom packages, pip, virtual environments (venv)
15. Resilience: exception handling with try- except- finally, custom exception classes, debugging

Practical Exercises: Reusable Modular Calculator • Employee Salary & Deductions Engine

Module 4: Object-Oriented Programming (OOP)

16. Classes, object instances, constructor patterns (_init_ ), self-reference mechanism
17. Inheritance: single, multiple, hierarchical, and method resolution order (MRO) with super()
18. Polymorphism, method overriding, data encapsulation, and private/protected attributes
19. Abstraction: ABC module, abstract methods, class methods, static methods, @property getters/setters
20. Magic dunder methods (_str_, _repr_, _call_ ), object composition vs inheritance

Applied Projects: Complete Banking Core Application • Enterprise Employee Management System

Module 5: Python for Real-World AI Development

1. File handling: reading and writing structured TXT, CSV, and JSON files
2. Working with nested JSON payloads and dynamic API response parsing
3. Python HTTP requests and networking using the requests library
4. REST API architectural patterns: handling GET, POST, PUT, DELETE methods
5. HTTP status codes, custom authentication headers, and session pooling
6. Environment variable management, system environments, and . env file isolation
7. Pydantic models, field validation, custom data validators, and schema generation
8. Type hints, annotations, static analysis, and Python typing constructs
9. Production logging levels, log handlers, file rotation, and execution debugging
10. Async Python architecture: event loop fundamentals, async, and await
11. Concurrency paradigms: threading vs multiprocessing vs non-blocking asyncio
12. FastAPI fundamentals: routing, path/query parameters, dependency injection
13. External AI API integrations, error boundaries, and retry policies
14. Source code control: Git branches, merges, workflows, and GitHub repository hygiene
15. Docker containerization: Dockerfiles, image building, containers, port mappings

Module 6: Python Libraries for AI

Core Scientific & Serving Stack

Library	Domain Role & Application in AI Development
NumPy	N-dimensional arrays, vector math, distance computations, and numerical matrix operations.
Pandas	Structured tabular data processing, dataset curation, cleaning, and evaluation transforms.
Requests	Synchronous HTTP networking for API communication and webhook triggers.
Pydantic	Strict data schema definition, runtime validation, and LLM structured output parsing.
FastAPI	Building high-performance asynchronous AI backend services and streaming endpoints.
python-dotenv	Loading environment configurations and securely managing provider API keys.
Logging	Application telemetry, trace capturing, and production monitoring.

Part II: LangChain Architecture, Models & Expression Language (LCEL)

Modules 7 to 11 • Foundations, model protocols, prompt templating, parser schemas, and runnable composition

Module 7: LangChain Fundamentals

1. What is LangChain and why use it in modern software development?
2. LangChain architecture and package ecosystem (langchain- core, langchain- community, partner packages)
3. LangChain vs Direct LLM API Calls: abstraction, portability, and lifecycle advantages
4. Installing packages and securely configuring API keys across model providers
5. Navigating and interpreting the current LangChain v0.2+ documentation and migration pathways

Module 8: Models and Messages

1. Chat models and model integration (OpenAI, Anthropic, open weights via Ollama/Groq)
2. Standard execution methods: invoke(), asynchronous ainvoke(), and concurrent batch()
3. Message schemas: SystemMessage, HumanMessage, and AIMessage
4. Configuring model parameters (temperature, max tokens, top-p) and analyzing response objects
5. Streaming real-time token responses using stream() and astream()
6. Monitoring token usage, tracking context limits, and robust API error handling

Module 9: Prompt Engineering

1. Prompt Templates: defining parameterized text templates for predictable completions
2. Chat Prompt Templates: structuring multi-turn dialogs with system and human roles
3. Dynamic variables and partial variable assignment for incremental prompt composition
4. Few-Shot Prompting: constructing example selectors and injecting curated exemplars
5. MessagesPlaceholder: dynamically injecting arbitrary conversational message histories
6. Reusable prompt modules, prompt serialization, and clean compositional pipelines

Module 10: Output Parsers and Structured Output

1. String output parsers (StrOutputParser) for extracting raw text from generation objects
2. JSON output and parsing: converting model completions directly into native Python dictionaries
3. Pydantic models: defining strict enterprise schemas, types, and validation rules
4. Pydantic output parsers: parsing raw model streams into strongly typed object instances
5. Model-supported structured output using with_structured_output() for deterministic generation
6. Managing validation failures, output self-correction, and parsing error fallback strategies

Module 11: LCEL and Runnable Components

1. LangChain Expression Language (LCEL): declarative composition paradigm
2. The Runnable Interface: standard contracts and protocol compliance
3. The Unix Pipe Operator (| ) for seamless component chaining
4. RunnableSequence: deterministic linear execution pipes
5. RunnableParallel: fan-out concurrent execution and multi-output gathering
6. RunnablePassthrough: carrying forward raw inputs and contextual data unchanged
7. RunnableLambda: wrapping custom Python transformations into native runnables
8. RunnableConfig: passing callbacks, tags, metadata, and runtime parameters
9. RunnableBranch: dynamic conditional routing based on intermediate logic
10. Execution protocols: comparing invoke(), batch(), stream(), and asynchronous counterparts

Part III: Advanced Workflows, Memory & Knowledge Engineering

Modules 12 to 16 • Composition pipelines, chat memory persistence, chunking, vector stores, and enterprise RAG

Module 12: Chains and Composition

1. Core composition pattern: Prompt $\rightarrow$ Model $\rightarrow$ Parser
2. Building sequential linear flows and parallel branched workflows
3. Conditional execution: dynamic logic branching based on incoming payloads
4. Combining multiple chains: hierarchical architectures and sub-chain orchestration
5. Data transformation between pipeline stages using custom transformation functions
6. Legacy chains (LLMChain, SequentialChain) and modern LCEL alternatives

Module 13: Chat History and Memory

1. Message history fundamentals: storing and restoring historical dialogue turns
2. RunnableWithMessageHistory: wrapping runnable pipelines with automated memory injection
3. Session IDs and user sessions: managing multi-tenant isolated conversation state
4. In-memory versus persistent chat history (ephemeral storage vs Redis/Postgres backends)
5. Conversation summarization, token budget tracking, and message trimming utilities
6. LangGraph persistence versus older memory approaches: checkpointers and state safety

Module 14: Documents and Text Splitters

1. LangChain Document objects and metadata structure: schemas and data provenance
2. Document loaders: batch processing, lazy loading, and generator patterns
3. Hands-on loaders: ingesting PDF, text, CSV, and web scraping with WebBaseLoader
4. RecursiveCharacterTextSplitter: hierarchical delimiter-aware text splitting
5. Chunk size and overlap optimization: preserving semantic context across chunk borders
6. Metadata filtering, boilerplate elimination, and raw document cleaning pipelines

Module 15: Embeddings and Vector Stores

1. What embeddings are: dense vector spaces, semantics, and dimensionality
2. Embedding models: proprietary embeddings vs open-source sentence-transformers
3. Semantic similarity metrics: Cosine Similarity, Dot Product, and Euclidean (L2) distance
4. Vector databases: hands-on indexing with FAISS and persistent Chroma collections
5. Vector store indexing, disk persistence, and real-time document additions
6. Similarity search and executing precise metadata filter queries
7. Retriever interfaces: converting vector stores to runnables and top-k retrieval configuration

Module 16: Retrieval-Augmented Generation (RAG)

1. RAG architecture: indexing, context retrieval, synthesis, and answer grounding
2. Build a basic RAG pipeline using declarative LCEL components
3. Retrieval and answer generation: context formatting and prompt injection defense
4. Conversational RAG: integrating conversational turns with external vector search
5 .History-aware retrieval: reformulating user queries based on conversation history
6. Hybrid search and reranking: combining BM25 keyword matching with cross-encoders
7. Query rewriting and multi-query retrieval: expanding prompts for high recall
8. Grounded answers and source citations: verifying claims and displaying document metadata

Part IV: Autonomous Agents, LangGraph & Production Engineering

Modules 17 to 20 • Tool binding, cyclic graph state orchestration, observability with Langfuse/LangSmith, and deployment

Module 17: Tool and Function Calling

1. Tool and function calling fundamentals: structured invocation payloads vs text
2. Creating custom tools with the @tool decorator and explicit type signatures
3. Tool schemas and descriptions: guiding LLM reasoning using clear schema docstrings
4. Binding tools to chat models using model. bind_tools()
5. Tool execution and capturing structured ToolMessage results back to the model
6. Current agent architecture: modern create_agent and ReAct agent patterns
7. Agent loops, recursion limits, and stopping conditions to prevent runaway iterations
8. Error handling, exception catching, fallback execution, and human approval checkpoints

Module 18: LangGraph with LangChain

1. When to use LangGraph: moving beyond DAGs to cyclic stateful graphs
2. StateGraph architecture: defining nodes, standard edges, and entry/exit points
3. State schemas, state reducers, and message list updates via add_messages
4. Conditional edges and loops: dynamic graph routing based on node state inspection
5. Checkpointer and thread IDs: saving graph snapshots and resuming user conversations
6. Interrupts and human-in-the-loop: pausing execution for review, editing, and authorization
7. Multi-step and multi-agent workflows: supervisor routers and hierarchical agents

Module 19: Evaluation and Observability (LangSmith & Langfuse)

1. Tracing LangChain and LangGraph applications: capturing execution trees and intermediate calls
2. LangSmith and Langfuse fundamentals: project setup, API credentials, tags, and run metadata
3. Debugging prompts, chain latency, and tool parsing exceptions in production traces
4. Dataset-based evaluations: curating test datasets and running benchmark assertions
5. Testing RAG retrieval and answers: assessing context recall, answer relevance, and faithfulness
6. Latency tracking, token expenditure accounting, error rate monitoring, and alerting

Module 20: Advanced Integration and Final Capstone Project

1. Connect LangChain & LangGraph backends to FastAPI or Flask web applications
2. Integrate databases (SQL/NoSQL) and external third-party enterprise REST APIs
3. Streaming responses: real-time Server-Sent Events (SSE) and token-by-token client rendering
4. Authentication, rate limiting, and secure enterprise secrets management
5. Production test architecture, modular code organization, and CI/CD deployment pipelines
6. Capstone Project: Build and ship an end-to-end production RAG chatbot or autonomous tool-using agent

Final Deliverable: Fully functional, containerized, evaluated, and deployed Agentic AI application ready for real-world user traffic.