Part 2 — Framework & Tool Integration
9 chapters · 22.1 study hours allocated in the Study Plan · 4 slide decks · 25 videos · 66 code example files
On this page
- Chapters
- Chapter summaries
- 2.1. Framework Landscape
- 2.2. LangGraph
- 2.3. LangChain
- 2.4. MultiAgent Frameworks
- 2.5. Semantic Kernel - Enterprise Framework and Plugin Architecture
- 2.6. Tool Integration and Function Calling
- 2.7. Multimodal RAG - Integration of Vision, Audio, and Text
- 2.8. Error Handling and Resilience
- 2.9. Streaming and Real-Time Responses
- Additional worked examples
- Labs
Chapters
Rating tags show which certification knowledge maps rate the chapter H (highly relevant) in at least one item: NV NCP-AAI · AWS AIP-C01 · DBX Databricks GenAI Engineer · GCP Professional ML Engineer · MS AI-102. See Certifications.
| Ch. | Title | Hours | Slides | Quiz | Videos | Figures | Code | H-rated for |
|---|---|---|---|---|---|---|---|---|
| 2.1 | Framework Landscape | 2.7 | PDF‡ | Quiz | 7 | — | 3 | NV AWS GCP MS |
| 2.2 | LangGraph | 1.6 | PDF‡ | Quiz | 7 | — | 11 | NV AWS GCP MS |
| 2.3 | LangChain | 1.4 | PDF‡ | Quiz | 4 | — | 8 | NV AWS GCP MS |
| 2.4 | MultiAgent Frameworks | 2.1 | PDF‡ | Quiz | 2 | — | 5 | NV AWS GCP MS |
| 2.5 | Semantic Kernel - Enterprise Framework and Plugin Architecture | 1.7 | PDF‡ | Quiz | 2 | — | 12 | NV AWS MS |
| 2.6 | Tool Integration and Function Calling | 4.0 | PDF‡ | Quiz | 1 | — | 4 | NV AWS GCP MS |
| 2.7 | Multimodal RAG - Integration of Vision, Audio, and Text | 5.3 | PDF‡ | Quiz | 1 | — | 7 | NV AWS GCP MS |
| 2.8 | Error Handling and Resilience | 1.3 | PDF‡ | Quiz | 0 | — | 7 | NV AWS GCP MS |
| 2.9 | Streaming and Real-Time Responses | 2.0 | PDF‡ | Quiz | 1 | — | 9 | NV AWS GCP MS |
Notes. The Videos column counts the videos shown under each chapter summary below, out of the unique direct links in Part_02_YoutubeVideos.md (“3 of 5”). A video is left out when its link is dead, embedding is disabled, or YouTube’s title does not match the entry; see the link check. Chapters can also list search suggestions instead of links.
† Linked by chapter-family number, not an exact ID match: the deck, quiz, or figure set is numbered differently from this chapter in the source files (for example a quiz or deck numbered 6.2 for chapters 6.2A and 6.2B).
‡ A combined deck that covers more than one chapter.
A chapter that is missing from a certification’s mapping file shows no tag for that certification: the NVIDIA file omits 4.1 and 10.6, and the other four omit 1.8, 9.16, and 9.17.
Slides for Parts 1–2 are the Agentic AI Book Club session decks, each covering two or three chapters.
Chapter summaries
Summaries are excerpted from Study_Plan.md, which also lists each chapter’s key concepts and self-check questions.
2.1. Framework Landscape
This chapter provides a systematic decision framework for selecting among five major agent frameworks (LangGraph, LangChain, AutoGen, CrewAI, Semantic Kernel) by analyzing how their control flow models match workflow architectures, state management requirements, and collaboration patterns. Through worked examples and contrastive cases, the chapter teaches readers to evaluate frameworks analytically rather than by popularity, ensuring architectural decisions align with long-term system requirements.
Videos (7)
Code examples (3 files)
2.2. LangGraph
LangGraph is a framework for building agentic workflows through explicit graph architecture with nodes as computational units, edges as control flow pathways, and state as shared context. The chapter explores how graph-based design enables iterative refinement, conditional routing, and recovery from failures while establishing when LangGraph’s sophistication is justified versus when simpler frameworks better match workflow requirements.
Videos (7)
Code examples (11 files)
LangGraph_code_01_complete_imports.pyLangGraph_code_02_state_schema_definition.pyLangGraph_code_03_code_generation_node.pyLangGraph_code_04_test_execution_node.pyLangGraph_code_05_error_analysis_node.pyLangGraph_code_06_state_graph_with_conditional_routing.pyLangGraph_code_07_execute_workflow.pyLangGraph_code_08_routing_with_quality_check.pyLangGraph_code_09_checkpointing_configuration.pyLangGraph_code_10_time_travel_debugging.pyLangGraph_code_11_simple_agent_executor.py
2.3. LangChain
LangChain’s AgentExecutor implements the ReAct pattern from Part 1 without requiring manual loop management, abstracting 150-200 lines of careful code into a single interface. The chapter covers agent types, tool integration patterns, and recognition of when workflows exceed LangChain’s linear model and require migration to LangGraph.
Videos (4)
Code examples (8 files)
LangChain_code_01_web_search_tool.pyLangChain_code_02_initialize_language_model.pyLangChain_code_03_configure_conversation_memory.pyLangChain_code_04_create_agent_with_prompt_template.pyLangChain_code_05_execute_queries_and_observe_reasoning.pyLangChain_code_06_poor_tool_description.pyLangChain_code_07_improved_tool_description.pyLangChain_code_08_robust_web_search_with_error_handling.py
2.4. MultiAgent Frameworks
This chapter explores two fundamentally different approaches to multi-agent coordination: AutoGen’s message-driven conversational architecture and CrewAI’s organizational structure model. It examines the trade-offs between conversational flexibility and reproducibility, along with patterns for composing multi-agent systems with specialized single-agent frameworks.
Videos (2)
Code examples (5 files)
2.5. Semantic Kernel - Enterprise Framework and Plugin Architecture
Semantic Kernel provides a central orchestration component managing service registration, plugin discovery, and execution coordination through dependency injection patterns. The framework distinguishes between semantic functions (LLM-powered reasoning) and native functions (deterministic code), enabling plugins to combine AI capabilities with reliable system integration while supporting dynamic routing through LLM-driven orchestration.
Videos (2)
Code examples (12 files)
Semantic_Kernel_code_01_service_registration_setup.pySemantic_Kernel_code_02_customer_service_plugin.pySemantic_Kernel_code_03_semantic_sentiment_analysis.pySemantic_Kernel_code_04_native_lifetime_value.pySemantic_Kernel_code_05_combined_functions.pySemantic_Kernel_code_06_function_calling_planner.pySemantic_Kernel_code_07_function_descriptions.pySemantic_Kernel_code_08_function_choice_behavior.pySemantic_Kernel_code_09_enterprise_crm_plugin_init.pySemantic_Kernel_code_10_native_crm_functions.pySemantic_Kernel_code_11_semantic_crm_functions.pySemantic_Kernel_code_12_plugin_orchestration_setup.py
2.6. Tool Integration and Function Calling
Tool integration establishes how language models request external tool execution through structured function calling, with applications responsible for parsing JSON, validating inputs, and managing execution. The chapter covers function calling mechanics, schema design using JSON Schema standards, tool chaining for sequential dependencies, parallel execution optimization, and production considerations including error handling and NVIDIA NIM optimizations.
Videos (1)
Code examples (4 files)
2.7. Multimodal RAG - Integration of Vision, Audio, and Text
Multimodal RAG extends retrieval-augmented generation to handle visual and audio content alongside text, addressing semantic alignment challenges through three architectural approaches: unified embedding spaces with CLIP, grounding all modalities to text with vision-language models, and separate stores with cross-modal reranking. The chapter covers vision model specialization, image routing logic, Whisper-based audio transcription with time indexing, and the NVIDIA multimodal stack for production deployment.
Videos (1)
Code examples (7 files)
2.8. Error Handling and Resilience
Error handling patterns establish production resilience through layered defense combining retry logic for transient failures, fallback strategies for persistent failures, graceful degradation maintaining partial functionality, and circuit breakers preventing cascading failures in multi-agent systems. The chapter addresses framework integration with LangChain and LangGraph, provides worked examples of resilient multi-tool agents, and explains how to achieve 99.9% uptime through comprehensive pattern application.
Code examples (7 files)
2.9. Streaming and Real-Time Responses
Streaming restructures agent response patterns from accumulate-then-display to generate-and-stream-simultaneously, addressing the blank screen psychological effect and user abandonment. The chapter covers the perceived latency principle where sub-second feedback matters more than total latency, Time to First Token optimization, protocol selection between Server-Sent Events and WebSockets, and LangServe integration for production streaming infrastructure.
Videos (1)
Code examples (9 files)
batch_response_endpoint_code_01_batch_response_endpoint.pydisconnection_detection_code_05_disconnection_detection.pyerror_handling_context_code_04_error_handling_context.pylangserve_basic_setup_code_07_langserve_basic_setup.pylangserve_rag_chain_code_08_langserve_rag_chain.pylatency_tracking_instrumentation_code_06_latency_tracking_instrumentation.pysse_client_consumer_code_03_sse_client_consumer.pystream_log_event_handler_code_09_stream_log_event_handler.pystreaming_response_setup_code_02_streaming_response_setup.py
Additional worked examples
From more_examples/part_02/:
Labs
No finished lab exists for this Part yet. These legacy example files are prose excerpts with embedded code, kept as source material; they do not count as lab coverage. See Labs.
