Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Build an Agentic AI Chatbot with LangGraph: Step-by-Step Tutorial

Added: 2026-08-06

Deep Dive

Basic understanding of LangChain concepts, including Runnables, LangChain Expression Language (LCEL), and tool integration.

Langchain LCEL Intuitively Explained + Notebook Examples | Langchain Tutorial

Langchain LCEL Intuitively Explained + Notebook Examples | Langchain Tutorial

915

LangChain Expression Language (LCEL) is a syntax for creating chains of tasks where the output of one task becomes the input of the next, built on two core concepts: runnables (functions wrapped for chaining) and the pipe operator (>>), which passes outputs between runnables; this enables building various chain types including basic prompt-model chains, custom runnables via RunnableLambda, multi-input chains using dictionaries interpreted as RunnableParallel, and concurrent execution of multiple chains.

Click to watch →

Langchain Runnables - Part 2 | Generative AI using LangChain | Video 9 | CampusX

Langchain Runnables - Part 2 | Generative AI using LangChain | Video 9 | CampusX

72.6K

LangChain Runnables are standardized components that enable flexible AI workflow construction, categorized into task-specific Runnables (like Prompt Templates, LLMs, Parsers, and Retrievers) and Runnable Primitives (RunnableSequence, RunnableParallel, RunnablePassthrough, RunnableLambda, and RunnableBranch) that orchestrate how these components interact sequentially, in parallel, or conditionally. The LangChain Expression Language (LCEL) provides a declarative syntax using the pipe operator (|) for defining chains, replacing explicit RunnableSequence instantiation with more readable expressions like R1 | R2 | R3.

Click to watch →

Understanding LangChain Runnables

Understanding LangChain Runnables

343

In LangChain, a runnable is a standardized interface that all components (prompt templates, chat models, output parsers, tools, retrievers, and chains) implement, enabling them to be composed together through three core methods: .invoke() for single synchronous calls, .batch() for parallel processing of multiple inputs, and .stream() for real-time token-by-token output processing; runnables can be composed in sequence (creating chains where each runnable's output becomes the next runnable's input) or in parallel (executing multiple runnables simultaneously), and the result of any composition is itself a runnable, enabling modular and composable LLM workflow construction.

Click to watch →

Deep dive into LangChain Expression Language (LCEL): Pipe Operator , Runnables, Async & Streaming

Deep dive into LangChain Expression Language (LCEL): Pipe Operator , Runnables, Async & Streaming

1.1K

Runnables are fundamental components in LCEL that enable chaining. RunnablePassthrough is a simple chain component that takes input and passes it through unchanged, useful when preserving input values. RunnableLambda wraps normal Python functions to give them an invoke method, enabling custom logic in chains. For example, a function like string.upper() can be wrapped with RunnableLambda and used in a chain. This allows developers to use their own custom logic within the LCEL framework while maintaining the chaining capability.

Click to watch →

LangChain Expression Language (LCEL) Explained!

LangChain Expression Language (LCEL) Explained!

22.4K

The LangChain Expression Language (LCEL) is a minimalist syntax abstraction that enables rapid chain development in LangChain by using a pipe operator (|) to string together components like prompts, models, and retrievers, with underlying implementation relying on the '__or__' method within a 'Runnable' class that chains functions together; this approach supports advanced features like streaming, async, and parallel execution out-of-the-box while allowing customization through RunnableLambda for wrapping custom functions and RunnableParallel for executing multiple components simultaneously.

Click to watch →

Deep Dive

Foundational knowledge of Retrieval-Augmented Generation (RAG), including vector embeddings, retrievers, and document chunking.

RAG Fundamentals and Advanced Techniques – Full Course

RAG Fundamentals and Advanced Techniques – Full Course

175.5K

Retrieval-Augmented Generation (RAG) is a framework combining retrieval-based and generation-based models to produce more accurate, contextually relevant responses. The core concept involves injecting custom data into large language models so they can answer questions about specific contextual information beyond their training data. RAG consists of two main components: the retriever identifies and retrieves relevant documents, while the generator combines retrieved documents with queries to generate responses. The workflow involves parsing documents, chunking them, creating embeddings via embedding models, storing embeddings in vector databases, transforming queries into embeddings, searching for similar items, and generating final answers augmented by retrieved information.

Click to watch →

RAG Crash Course with LangChain: A 2.5 Hour Practical Guide

RAG Crash Course with LangChain: A 2.5 Hour Practical Guide

Retrieval-Augmented Generation (RAG) is a technique that optimizes large language model outputs by referencing an authoritative external knowledge base outside the model's training data, thereby preventing hallucinations and enabling integration of organizational data without expensive model retraining; the complete RAG pipeline consists of two main stages: the data injection pipeline (which involves document parsing, chunking, and embedding into a vector database) and the retrieval pipeline (which converts user queries to vectors, retrieves relevant context from the vector store, and augments LLM prompts with this context before generation).

Click to watch →

Introduction To Undertsanding RAG(Retrieval-Augmented Generation)

Introduction To Undertsanding RAG(Retrieval-Augmented Generation)

162.7K

Retrieval-Augmented Generation (RAG) is a technique that optimizes large language model outputs by referencing an authoritative external knowledge base before generating responses, addressing two key limitations of standalone LLMs: (1) hallucination when answering questions about events outside the model's training data timeframe, and (2) inability to access proprietary or organizational data without expensive fine-tuning. The RAG pipeline consists of two main components: a data injection pipeline that processes external data (PDF, HTML, Excel, SQL, etc.) through parsing, chunking, and embedding into a vector store, and a retrieval pipeline that converts user queries into vectors, performs similarity search in the vector database to retrieve relevant context, and augments the LLM prompt with this context before generating the final output.

Click to watch →

Cómo Crear Agentes de IA & Automatizar Procesos | Tutorial Completo desde Cero 2025

Cómo Crear Agentes de IA & Automatizar Procesos | Tutorial Completo desde Cero 2025

191K

RAG (Retrieval-Augmented Generation) enhances AI responses by combining model knowledge with external document sources. The architecture requires three key components: text splitting to divide large documents into manageable chunks (typically 100-200 characters with overlap), embeddings to convert text into numerical vectors for efficient searching, and vector databases to store and retrieve relevant information. This enables AI to answer questions based on specific documents rather than relying solely on pre-trained knowledge, making the system more accurate and up-to-date.

Click to watch →

16 Months of Building AI Agents in 60 Minutes

16 Months of Building AI Agents in 60 Minutes

200.2K

RAG (Retrieval-Augmented Generation) is a technique that overcomes the limitation of LLMs having access only to their training data. It combines three core elements: an embedding model (which converts text into vectors), a vector store (which stores these vectors), and a language model. When a user asks a question, the system converts it to a vector, retrieves similar vectors from the store, and passes the relevant information back to the language model for generating an answer. This allows LLMs to access specific domain knowledge or uploaded files.

Click to watch →

Deep Dive

Familiarity with the ReAct (Reasoning and Acting) design pattern, which dictates how LLMs interact with external APIs.

Building end-to-end AI Agent in LangChain | Generative AI using LangChain | Video 18 | CampusX

Building end-to-end AI Agent in LangChain | Generative AI using LangChain | Video 18 | CampusX

109.8K

REACT is a design pattern for AI agents that stands for Reasoning + Acting. It allows language models to interleave internal reasoning with external actions in a structured multi-step process. Unlike single-turn LLM interactions, REACT enables agents to perform complex multi-step tasks by combining reasoning capabilities with tool usage.

Click to watch →

Introduction to Agentic Systems

Introduction to Agentic Systems

305

Agents are multi-turn systems that make multiple calls to LLMs, unlike simple LLM calls. A Large Language Model is a neural network trained to predict the next token of any input sequence, which can include text, images, video, or sound. The fundamental limitation of LLMs is that they can only output tokens and cannot perform actions or make API calls. Agents solve this by being intelligent software that can perform actions through tool calls. An agent consists of four components: the agent (in your control), the LLM (the brain), tools (external systems/APIs), and memory (conversation history). The LLM decides when to use tools, which tools to use, and what arguments to pass. Tools are implemented as functions that make API calls, with definitions including the function name, description, parameters, and return type. Guardrails are safety mechanisms implemented in the system prompt to prevent harmful actions. Public tools like Figma and Indigo can be connected through MCP (Model Context Protocol) servers. The ReAct (Reasoning and Acting) pattern is a common design pattern for agents: (1) User makes a query, (2) The LLM thinks and suggests an action (tool call), (3) The tool is executed and observed, (4) The LLM thinks again and decides on the next action. Memory stores previous interactions, tool calls, and their observations, providing additional context for the agent.

Click to watch →

03: Prompting and Zero-Shot Inference – Large Language Models (NUS CS6101 NUS.WING)

03: Prompting and Zero-Shot Inference – Large Language Models (NUS CS6101 NUS.WING)

519

This section introduces REACT (Reasoning, Acting, Observing, Reflecting, Transforming), a framework enabling language models to interact with external environments through APIs. It covers: the four-component architecture (thoughts, actions, observations, transformations); why combined reasoning and acting outperforms either alone; benchmark evaluations on OpenQA, FEVER, L4, and WebShop; performance results showing superiority over alternatives; limitations including model-size dependence; and fine-tuning strategies for smaller models.

Click to watch →

Gen AI Part 9 - Introduction to Agentic AI (Create Autonomous Agents)

Gen AI Part 9 - Introduction to Agentic AI (Create Autonomous Agents)

1.8K

The ReAct (Reason and Act) agent framework is a powerful design pattern that enables large language models to perform complex tasks by combining reasoning and acting. Unlike traditional linear chains, ReAct allows LLMs to think critically about problems, choose appropriate tools to solve parts of them, observe results, and refine their approach. The framework operates in a loop: think (reasoning based on knowledge and memory), act (call APIs, databases, or external tools), reflect (review results), and observe (evaluate if outcome is near completion). If not complete, the loop continues. For example, when asked about the capital of France and its current population, the agent uses a search tool to find the population data before responding.

Click to watch →

LLM Chronicles #6.5: Build LLM Agents from Scratch: PAL, ReAct & Langchain in 1 Hour

LLM Chronicles #6.5: Build LLM Agents from Scratch: PAL, ReAct & Langchain in 1 Hour

35.5K

ReAct (Reason + Act) is an agent framework combining Chain-of-Thought reasoning with external tool execution. The agent operates in a loop: it generates thoughts about next actions, calls functions/tools, receives observations, and continues until finding final answers. Implementation requires designing a prompt template specifying available tools and the operational loop format. A critical component is the stop condition preventing LLM hallucination of observations. Action extraction from LLM output depends entirely on the chosen format (text, JSON, XML). The framework enables agents to interact with external systems, improving capabilities for tasks requiring both reasoning and real-world data access.

Click to watch →

Deep Dive

Intermediate Python programming skills, including asynchronous programming (async/await) and handling state dicts.

Основы асинхронности в Python #7: Asyncio, async/await

Основы асинхронности в Python #7: Asyncio, async/await

115K

The asyncio module in Python provides a framework for creating asynchronous programs using event loops, where coroutines (implemented as generator functions) are wrapped in Task objects and scheduled for concurrent execution; the async/await syntax (introduced in Python 3.5) simplifies coroutine creation and execution by using the async keyword to define coroutines and await to call them, enabling efficient handling of I/O-bound operations like network requests without blocking the event loop.

Click to watch →

Next-Level Concurrent Programming In Python With Asyncio

Next-Level Concurrent Programming In Python With Asyncio

210.9K

The async and await syntax in Python is the mechanism for achieving concurrency. When you write 'async' in front of a method or function, you indicate that it's allowed to run this method or function concurrently. The 'await' keyword gives you control over the order that things are being executed. When you write 'await' in front of a concurrent statement, this means that the portion written below that statement can only be executed after the concurrent statement has completed. This is important when the next part of your code relies on the result of the previous part, such as needing to wait until you get data back from a database or confirmation from an API before continuing.

Click to watch →

Python tricks: Demystifying async, await, and asyncio

Python tricks: Demystifying async, await, and asyncio

95.7K

Asynchronous programming in Python allows multiple functions to appear to run in parallel within a single thread by rapidly alternating between them, unlike synchronous code which runs one function at a time; to write effective async code, developers must use the async/await keywords, design functions to yield control at suspension points (such as using asyncio.sleep instead of time.sleep), and leverage the asyncio module's non-blocking I/O functions, which enables better performance especially for I/O-bound tasks like network requests.

Click to watch →

All 39 Python Keywords Explained

All 39 Python Keywords Explained

297.7K

Python supports asynchronous programming using the async/await keywords, which require importing asyncio. The 'async def' keyword defines coroutine functions that can run asynchronously. The 'await' keyword is used inside async functions to pause execution until an asynchronous operation completes (such as waiting for I/O operations). This allows multiple tasks to run concurrently rather than sequentially, improving performance for I/O-bound operations.

Click to watch →

Асинхронность в python

Асинхронность в python

8.4K

This section covers Python's async/await syntax for implementing asynchronous code. The 'async' keyword marks functions as coroutines that return Task objects instead of executing immediately. The 'await' operator pauses execution and waits for Task completion, but can only be used inside async functions. This creates chains of asynchronous calls where each function can call others and await their results. The chain cannot be broken by synchronous code, as this would defeat the purpose of asynchrony.

Click to watch →

React架构

工具集成

环境配置

工具创建

模型绑定

流程构建

工作流验证

多工具协作

React架构

4:01

Playing Section

1
解释基于推理与行动构建聊天机器人的核心架构。
2
AI助手根据输入决定是否调用工具获取上下文信息。
3
为后续实现模型上下文协议奠定理论与实践基础。

Deep Dive

Advanced Multi-Agent Architectures: Designing collaboration networks where specialized agents communicate and hand off tasks.

The 5 Levels of AI Agent Complexity (what actually works in production)

The 5 Levels of AI Agent Complexity (what actually works in production)

2.7K

This section explores Levels 4 and 5 of AI agent complexity. Level 4 (Agent Harnesses) provides complete runtime environments with file system access, web search, and external API integration, enabling powerful but experimental capabilities. Level 5 (Multi-Agent Orchestration) uses orchestrators that spawn sub-agents with separate context windows, solving context window bloat during long tasks. These advanced patterns remain experimental and require careful consideration of reliability, cost, and security before production deployment.

Click to watch →

Curso GRATIS de Crear tu Agencia de Agentes IA paso a paso (+5 horas)

Curso GRATIS de Crear tu Agencia de Agentes IA paso a paso (+5 horas)

9.9K

Output parsers ensure AI responses follow specific formats like JSON with defined variables, enabling programmatic use in applications. Advanced systems create trees of agents where one agent calls another, each with dedicated AI for chat, memory, and output processing. This distributed architecture allows complex tasks to be divided among specialized agents, enabling capabilities impossible for single agents. The key insight is that agents use multiple AI calls in different ways to produce responses 10 times better than humans.

Click to watch →

Deep Agents Explained

Deep Agents Explained

596

Effective prompt engineering for agents involves keeping prompts organized with good and bad examples, running multiple versions to evaluate performance, and not forgetting about tools as tool descriptions affect how well agents can take action. Deep Agents support four main multi-agent architectures: (1) Router architecture for deciding which agent handles each query, (2) Subagent architecture where agents delegate to specialized sub-agents, (3) Skills architecture where different agents with different skills represent different personas, and (4) Custom workflow architecture. The subagent architecture was chosen because it has proven successful in other powerful harnesses.

Click to watch →

Curso n8n from Zero to Hero - Implementación de Agentes y Multiagentes

Curso n8n from Zero to Hero - Implementación de Agentes y Multiagentes

5.8K

Multi-agent systems coordinate multiple specialized agents for parallel processing. Linear multi-agent workflows process tasks sequentially: Agent 1 handles LinkedIn posts, Agent 2 handles X posts, Agent 3 handles blog posts. Advanced multi-agent systems use a coordinator agent that manages multiple specialized agents, enabling parallel execution. The coordinator can query databases, access specialized tools, and direct different agents to perform specific tasks. This architecture is more efficient than sequential single-agent workflows, as multiple tasks can be executed concurrently.

Click to watch →

Conceptual Guide: Multi Agent Architectures

Conceptual Guide: Multi Agent Architectures

106.9K

Multi-agent systems address scalability limitations of single-agent systems by breaking down complex tasks into specialized agents; common architectures include networked agents (loose coupling, unreliable), supervisor agents (centralized routing), hierarchical agents (layered supervision), and custom cognitive architectures (domain-specific); agents communicate through shared state objects or tool calls, with the most successful production systems typically requiring custom architectures tailored to specific domains.

Click to watch →

Deep Dive

State Persistence and Human-in-the-Loop: Implementing checkpointers to enable conversational memory, 'time-travel' debugging, and manual human approvals.

LangGraph - Persistence & Human-in-the-Loop Workflow

LangGraph - Persistence & Human-in-the-Loop Workflow

4.2K

LangGraph enables conversation persistence through checkpointers (like SQLite in-memory databases) and supports human-in-the-loop workflows by interrupting execution at specific nodes (such as the tools node) to allow humans to grant permission for tool usage or override LLM responses by manipulating the state messages.

Click to watch →

Persistence in LangGraph | Time Travel in LangGraph | CampusX

Persistence in LangGraph | Time Travel in LangGraph | CampusX

50.2K

Human-in-the-loop workflows pause execution to wait for human input. Persistence enables this by saving state at the pause point, allowing resumption when human input arrives. Time travel allows replaying workflow execution from specific checkpoints by providing checkpoint IDs when invoking. This is useful for debugging complex workflows by jumping to specific points and observing execution paths without running from the beginning.

Click to watch →

Retrieval Augmented Generation(RAG) LangGraph Crash Course In Hindi

Retrieval Augmented Generation(RAG) LangGraph Crash Course In Hindi

306

LangGraph provides key capabilities: (1) Persistence - ability to save and restore workflow state at any point, (2) Human-in-the-Loop - ability to pause workflow execution and allow human intervention, (3) State Management - systematic management of workflow state throughout execution, and (4) Graph-Based Design - structured approach to designing complex workflows. State snapshots capture complete state including current values, next node to execute, and metadata. These capabilities make LangGraph suitable for production AI applications requiring reliability, traceability, and human oversight.

Click to watch →

Build Agentic Workflows with Mastra - The TypeScript Agent Framework

Build Agentic Workflows with Mastra - The TypeScript Agent Framework

1.6K

Mastra persists workflow state using configurable storage engines, enabling human-in-the-loop interactions where workflows suspend and resume based on human approval. The MCP Doc Server addresses code editor limitations by providing documentation access through agentic RAG, making editors like Cursor and Windsurf experts on Mastra. Workflows register through central indexes enabling tracing on every decision. The framework supports multiple deployment patterns: bundled within frameworks like Next.js for simple apps, or as standalone backend services for complex architectures. The client SDK provides consistent APIs regardless of deployment pattern, abstracting implementation details while maintaining functionality.

Click to watch →

Anthropic admits that MCP sucks

Anthropic admits that MCP sucks

139.5K

LLMs have no state, while databases are stateful. Code execution bridges this gap by keeping state within the code execution environment. As long as data is in memory, it hasn't changed. If persistence is needed, data can be written to files, eliminating concerns about state being lost from context. Agents can also persist their own code as reusable functions for future use.

Click to watch →

Deep Dive

Agent Evaluation and Tracing: Utilizing LangSmith or Ragas to benchmark, trace, and optimize the decision-making pathways of the graph.

Agent Bricks | Workshop Práctico

Agent Bricks | Workshop Práctico

280

Agent evaluation involves testing agents with sample questions and expected responses. MFlow captures traces showing exactly what the agent did: which tools it called, what queries were executed, what responses were received, and how the final answer was generated. This visibility enables debugging and understanding agent behavior. Organizations can create custom judges to measure specific requirements, such as verifying that the agent always calls the Genie Space when needed. Traces show detailed information about each step, enabling precise debugging and performance optimization.

Click to watch →

Tracing Mastra Agents and Running Online Evals

Tracing Mastra Agents and Running Online Evals

419

This video demonstrates how to trace and evaluate Mastra agents using Arize AX, showing how to configure an exporter to send tracing data to Arize, set up span-level evaluations (like safety checks for LLM outputs) and trace-level evaluations (like relevance assessments), and run online evaluations that automatically execute as agents run, providing visual feedback on agent performance through the Arize UI.

Click to watch →

Building Better AI Agents: Observability and Evaluation

Building Better AI Agents: Observability and Evaluation

2K

Agent observability fundamentally differs from traditional software debugging because agents are non-deterministic systems whose behavior emerges from sequential LLM calls, requiring tracing of individual runs, traces (complete agent executions), and threads (multi-turn conversations) to enable effective evaluation; this observability data powers multiple evaluation approaches including single-step testing, full-turn validation, and multi-turn analysis, with traces serving as the primary source of truth for both debugging and continuous improvement of agent systems.

Click to watch →

Susan Shu Chang-✕-Evaluating AI Agents in production with Python-PyData Boston 2025

Susan Shu Chang-✕-Evaluating AI Agents in production with Python-PyData Boston 2025

115

Building effective AI agent evaluation requires two foundational components: creating realistic test data sets through manual labeling (including positive and negative cases), and establishing comprehensive tracing infrastructure using tools like Langsmith, Phoenix, or Langfuse. Manual labeling is essential when publicly available data is scarce, starting with small datasets (10-100 examples) and scaling iteratively. Tracing tools capture every decision point, tool call, and interaction flow in agentic systems, preventing them from becoming black boxes. This infrastructure enables both offline evaluation data collection and real-time production monitoring, forming the backbone for all subsequent evaluation activities.

Click to watch →

Mosaic AI Demo from the Data+AI Summit 2024

Mosaic AI Demo from the Data+AI Summit 2024

3.4K

Agent evaluation uses human feedback to assess quality through review apps where users provide thumbs up/down responses. Feedback logs in Delta tables enable evaluation datasets for production confidence. MLflow tracing captures complete system workflows from input to output, creating stack views showing data transformation through each step. This enables debugging by identifying where agents hallucinate or retrieve irrelevant data. Fixes include increasing relevance thresholds and improving prompt engineering to prevent summarizing irrelevant context.

Click to watch →

Deep Dive

Production-Grade Deployment: Packaging LangGraph applications using LangGraph Cloud, FastAPI, and robust error-handling mechanisms for tool failures.

Stop Overpaying for AWS — Build Your Own Production VPS (Step-by-Step)

Stop Overpaying for AWS — Build Your Own Production VPS (Step-by-Step)

246

This section covers the final critical components for production-grade deployment. SSL certificate management uses Let's Encrypt with Certbot, requiring daily cron job renewals to prevent expiration every 90 days. The deployment automation is achieved through a shell script that pulls code from GitHub, builds Docker images, runs containers, and waits for health checks before completion. CI/CD implementation adds GitHub Actions workflows that trigger the deployment script on code pushes or PR merges, with SSH keys configured in GitHub secrets for secure server access. Load balancing is automatically handled by Nginx's internal DNS resolution and round-robin distribution. This complete setup enables a single command deployment that substitutes expensive cloud services while maintaining production-grade reliability and security.

Click to watch →

Fable 5 is INSANE: Build ANY App in Plain English (No Code)

Fable 5 is INSANE: Build ANY App in Plain English (No Code)

736

This segment explores how AI builds production-grade applications across multiple domains. A trading floor application demonstrates multiple AI agents handling market data, research, backtesting, and risk management with features like audit trails and kill switches. A TV station application runs as a self-restarting system service with media libraries and live streaming. A social app implements WebRTC video calls with real database logging. A PDF editor is deployed by cloning open-source tools from GitHub. The consistent pattern across all builds is the Think-Plan-Execute-Verify loop, where the AI installs dependencies, runs scripts, reads errors, patches issues, and redeployed autonomously.

Click to watch →

7 Sensors You Should NEVER Use in a Product

7 Sensors You Should NEVER Use in a Product

40.7K

When selecting sensors for production products, five critical factors must be evaluated: accuracy, life cycle, compliance, power consumption, and safety. Hobbyist sensors like the DHT11/DHT22 temperature sensors, HC-SR04 ultrasonic distance sensor, HCSR501 motion sensor, MQ series gas sensors, MPU-6050 IMU, cadmium sulfide photoresistors, and ACS712 current sensor modules should be avoided in final products due to issues including poor accuracy, non-standard protocols, supply chain concerns, RoHS compliance violations, high power consumption, and safety hazards. Production-grade alternatives such as Sensirion SHT40/41, ST VL53 time-of-flight sensors, Panasonic EKMB series, Sensirion SGP40/41, TDK ICM-42688, Vishay VEML7700, and shunt resistors with isolated amplifiers provide reliable, compliant, and safe solutions for commercial products.

Click to watch →

ML Models Deployment with Flask and Docker | Machine Learning | Community Webinar

ML Models Deployment with Flask and Docker | Machine Learning | Community Webinar

11.1K

Production deployment requires moving beyond Flask's development server to proper WSGI servers like Gunicorn (Unix) or Waitress (Windows) that handle concurrent requests efficiently. Containerization with Docker provides isolation by packaging the application with its exact dependencies in a self-contained environment. The Dockerfile specifies base images, installs dependencies without virtual environments, copies model files, and defines startup commands. Key instructions include EXPOSE for documenting container ports and proper port mapping (-p host:container) when running containers. This approach ensures consistent behavior across development, testing, and production environments while providing isolation and reproducibility.

Click to watch →

Production-Grade AWS EKS Deployment | ALB, TLS, Route 53 + Terraform Automation

Production-Grade AWS EKS Deployment | ALB, TLS, Route 53 + Terraform Automation

163

This tutorial demonstrates how to deploy a production-grade Kubernetes application on AWS EKS using Terraform automation, covering the complete traffic flow from user browser to Kubernetes pods through AWS ALB with TLS termination, Route 53 DNS, and Kubernetes Ingress with both path-based and host-based routing configurations.

Click to watch →

React架构

工具集成

环境配置

工具创建

模型绑定

流程构建

工作流验证

多工具协作

React架构

4:01

Playing Section

1
解释基于推理与行动构建聊天机器人的核心架构。
2
AI助手根据输入决定是否调用工具获取上下文信息。
3
为后续实现模型上下文协议奠定理论与实践基础。

55.9K views1.3K1:04:46@krishnaik06Original Release: 2025-04-15

This tutorial demonstrates how to build a multi-tool chatbot using LangGraph's React architecture (Reasoning and Acting framework), where an AI assistant first reasons about whether to use tools or provide direct answers, then acts accordingly by making appropriate tool calls when necessary, enabling the chatbot to handle complex queries by integrating multiple tools like RRF, Wikipedia, and internet search APIs within a single workflow.

[00:00:00]Heat. Hey. Hey. Hey.

[00:00:02][Music] Hello guys, am I audible? Can you give me a quick confirmation if you are able to hear me out?

[00:00:46]Yep. Yep. Yep.

[00:00:51]Yep. Okay. uh we'll wait for some time so that everybody joins yet another exciting session in Langraph.

[00:01:05]Okay. Yeah, I'm audible I guess. Great. Let me check from my end if looks fine. Hello DHS. Hello everybody. Hello from Peru. Hi Mario. So I'm also live in LinkedIn. So people are able to hear me in LinkedIn also. Ravi Shakarwarma says yes. Okay. We also have people from Turkey.

[00:01:44]Great. Okay. Uh welcome everyone. This is the tutorial third and in this session we are going to discuss about uh how to build chat bots with the help of langraph. Again a practical session completely and yes uh we will also see how we can probably go ahead and implement things. Okay. Uh so please make sure that you hit like because this langraph series is going to go on for a longer time and soon we also going to start with MCP. again I will be using Langra framework itself for doing all the necessary things itself okay so yeah I hope everybody uh is probably audible you are able to hear me out and yes I watch lecture but it difficult difficult to execute in code no worries will help you in that please end to end projects perfect that also I will plan okay so let me quickly go ahead and share my screen and then we are just going to start with each and everything. Okay.

[00:02:43]So, just let me know once you're able to see my screen.

[00:02:51]Yeah. Hi K Manoj here from Bangalore.

[00:02:56]Hello. Thank you very much sir. Uh is MLOps compulsory before learning LLMs? No, not not necessary but it is good to have. Okay. So everybody uh I hope you all are ready. I hope you are able to hear me out quickly. So let's go ahead and let's work on today's use case.

[00:03:17]Okay. So here our main plan over here is that we are going to build a chatbot. So first of all I'll go just go ahead and write about the entire agenda what all things we are basically going to discuss. Okay. So we are going to create a chatbot with the help of Langraph. Now this will not just be a simple chatbot. With this we are going to integrate tools multiple tools. I'm not talking about just one tool multiple tools. And then we will try to also discuss about a react architecture. I don't know how many of you have heard about this react architecture. So that you know your chatbot will be specifically working based on this react architecture. Okay.

[00:04:16]Now what exactly is this react architecture? This is not a JavaScript framework react. Okay. It is something else. Um we we say this as based on reasoning and acting. Okay. So here specifically we use two terms. one is reasoning and then you are acting.

[00:04:36]Okay. So now in this chatbot see later on the reason why I'm explaining you this because soon we also going to start to talk about MCP. Okay. MCP that is model context protocol. Model context protocol. Okay. Model context protocol.

[00:04:54]And if I talk about model context protocol here we'll also try to develop some kind of protocol. how langraph or any AI assistant will be able to communicate with this kind of tools.

[00:05:04]Okay. But first of all as usual we will cover all this specific stuffs. We will implement it practically. We will try to understand each and everything with respect to this. Okay. Now quickly going ahead you know uh what we are basically going to do what uh what is our plan uh you know uh that I'm actually going to talk about. No.

[00:05:27]So here we are going to create a workflow. This workflow will be nothing but it is a chatbot workflow. Chatbot workflow. Now inside the chatbot workflow what we are basically going to do is that we will create something like this. Let's say this is my start node. This is my start node. Okay.

[00:05:55]inside my workflow. This will be my AI assistant. Let's say this is my AI assistant. And this AI assistant, let's say this will be having some Grock opensource models. That is what we are going to use. We are not going to use OpenAI because I hope everybody will be able to uh get the Grock access because it is completely for free at least for some number of request. And this AI assistent will will have will have um the access to tools, right? So this is basically going to have the access to some tools.

[00:06:37]Okay. Now what all tools I will try to create? We can create anything like let's say I have RIFF tools. I have Wikipedia tools.

[00:06:50]Okay. Or I may have any any internet search tool. Okay.

[00:06:57]Internet search tool. Okay. Now based on this specific tool what will happen is that once I have this particular tool that basically means when I ask a question that the LLM will not be knowing it. You know let's say that if I ask hey what is the current news? what is the news for this particular day let's say what is the news of April 14th what is the recent AI news on April 14th so what AI assistant will do is that it will try to go ahead and see that hey what tools it specifically have you know and based on these tools let's say that it is having this internet search tool so based on this particular information we will get some kind of response okay we'll get some kind of response otherwise if I'm doing any search that requires a Wikipedia search we can also go over here okay so this once we get this specific information then we are going to go towards the end section. Okay, end section. Now this is my entire workflow that I am going to create. This is the entire workflow that I am going to create with the help of langraph. Does this make sense everybody? Yeah. Can I get a quick yes if you are able to understand it? You know the reason why I'm making this why I'm showing you because in the future sessions what I will do is that I'll replace this tools and in between I'll become I'll I'll bring a MCP protocol and through that you will be able to call this service providers you know how we will be able to call it I will talk about it okay but here I hope you are able to understand now we spoke about something called as react architecture okay reasoning and acting right see When AI assistant is getting some kind of input, you know, it is basically asking this particular tools whether you have that specific output for this input or whether you can serve that particular uh information whatever information the human is basically giving. Are you able to help us out with that? And one of the tool will basically give you the kind of response. Right? Now here my AI assistant is basically the brain, right? brain right here. My AI assistant is basically the brain. As soon as I get an input, AI assistant will be responsible in making the tool call. Okay, tool call. This will be responsible, right? It'll it'll be responsible because we have already integrated all these tools with our AI assistant for this specific node. For this specific node, this will know, hey, we have to probably go ahead and make the tool call. I will show you practically how do we integrate it each and everything. Don't worry about it.

[00:09:46]Now once it knows hey I need to make a tool call. So it will just go ahead and make a tool call for this particular node. So this will be also a node and this node I will name it as something called as tool node. Something called as tool node. So in langraph you have something called as tool node. Tool node basically means it is a kind of node which is integrated with some tools. Okay, it is basically integrated with some kind of tools. So here I have multiple tools. So all these things are integrated in a tool node. So what happens is that once a request goes to this specific node this node which has the LLM. So this node has the LLM integrated over here. It will be able to decide whether there is a tool call or not. If there is not a tool call, this will give the response and it will go to end. Otherwise, this will decide hey whether we need to make a tool call. So here we make a tool call based on the input. We basically call that specific tool get the output and give it to the AI assistant. And this is what a React architecture basically works. React architecture basically works. Okay. And I should not be naming it something like this. It should be something like react.

[00:11:05]Okay.

[00:11:07]React. Okay. Now let's say if my question is something like this. I have a tool. Okay. I I'll say hey tell me about research paper and I will give the research paper number. Okay. And then I'll say hey then search for AI what is AI agents or tell me what is AI agents okay so if this kind of question is there here you can see I have two questions first question is that I'm saying hey tell me about the research paper and the research paper name so in this particular scenario when this input goes the AI assistant will first of all understand Hey, this is my first part of the sentence. Okay. So after seeing this particular sentence, it will think hey whether I need to make a tool call.

[00:12:07]Since we are talking about research paper and I've got the research paper name, I have a tool which is called as RF. So definitely I will first of all take this part go ahead and hit the tools and go ahead and hit my RF tool and get the response back. Right? Then the AI assistant will think hey still there is some more input that is left now what should be my next step right what should be my next step now it is saying that hey what is AI agents now it will just go ahead and see whether the LLM can provide the response if the LLM can provide the response AI assistant will then provide the response it will say that hey now I don't need to make a tool call I have to probably give the answer right so what happens the first context answer will be something else the Second context answer will be given by the AI assistant and finally this node will combine them and give it till the end that basically means to the user. Okay. So here react basically means reasoning and acting right. So based on every input this AI assistant which is having this specific LLM is able to think right and then act. Yes, I hope everybody's able to understand over here. Can I get a quick yes? If you are understanding everything what I'm explaining over here and if you like this explanation, please make sure to hit like and make sure to support the channel. Uh at the end of the day, all these things are specifically free for you all. Right. So tell me are you able to understand what is a react architecture?

[00:13:41]Yeah, perfect. So till here I hope everybody's clear. Now what I will do, I will just go ahead and start writing the code. Okay. Now it'll be amazing. Now previous example we built this simple uh simple graph you know simple graph over here. Right now what I'm actually going to do I will just go ahead and bring uh build some kind of so I'll write three langraph lang graph and I'll say hey tools or I can go ahead and write langraph tools. Okay. So, chatbot plus tools I will go ahead and write. So, here I will write chatbot multiple tools ipv. Now, let me just go ahead and show you everything step by step. Are you ready? Don't worry about the notes and the materials. Uh in the description there is a registration link where you can go ahead and just enroll it over there. I will put the code in that particular dashboard. Okay, is everybody ready? Shall we go ahead with the code? Yeah, give me a quick yes if you are specifically ready and then we are good to go.

[00:14:55]Okay. Now, first of all, what I will do, I will just go ahead and create since I'm going to use a uh LLM model. So, first of all, I'm just going to go ahead and create my ENV file. Now, inside my file, I'm going to use a API key, which is my gro API key.

[00:15:12]Right? So I hope everybody knows what a Grock API key is, right? So if you go to let me just open my browser.

[00:15:25]Okay. So here console.grock.com. Right. So inside this gro if you see just go ahead and click on playground. Here you'll be able to see there are so many different different kind of open source models right so we are going to use this opensource models specifically for uh doing all the works that we have right now if you want to get the API key just click on the API key create the API key I think if you are religiously following my YouTube channel you should be able to understand how to create an API key long back I've actually taught you okay just go ahead and create the API key and be ready with the API Now the next step is that I will just go ahead and open my file. So here I have pasted my API key the gro API key which we are going to specifically use in requirement.txt we have written all these particular libraries if require any kind of other libraries we will just go ahead and update it. Uh for right now let me just go ahead and update some of the libraries since we are going to also use a gro. So one is the python.enb. Now this specific library actually helps us to load the environment key variables from the env file. The next thing is that as I said you I'm just going to go ahead and write lang chain- groc. Okay. So this is also I will be requiring it. Perfect. Now till here I think everybody is very much clear with all the things that we have specifically done. Okay. And uh we will just go ahead and start our coding and first of all we will try to build uh the chatbot with multiple tools. Okay. So, uh before I go ahead, as I said already that here I'm going to use some different different libraries like Rafe tools, Rafe, Wikipedia, uh and there may be some more additional tools based on your tools that you can specifically use. Okay. And Langchain actually provides this specific tools also. So for this I will also go ahead and import two more libraries. One is RSIF and Wikipedia since we are going to use these two tools. Now I'll just go ahead quickly. I will write pip install minus r requirement.txt. Okay. Um soon I'm also going to move it to the UV package and recently I've also uploaded a video on that. If you have not seen that, please do let me know. Definitely do check it out. It is quite faster when compared to uh pip. Yeah. Now uh let's go ahead and write our code in chat multiple tools. Okay. Now the initial stage will be that I will first of all go ahead and create my tools. Okay tools. Okay. Now here the two tools that I'm actually going to use is RIV and Wikipedia. Okay.

[00:18:15]So for RSV if you just go ahead and probably see in langchain I will be able to see that how do we call RFI tool. I will just go ahead and write RF and here you have right. So if I just go ahead and click on this, you'll be able to see that hey, we require this RSF over here.

[00:18:36]Okay. And uh here you have something called as RF loader. Okay. And how do you specifically run this particular tool? All those particular information is basically there. Right? We have already done the installation of RF. So what I will do, I will just go ahead and write down the code. Again, you can refer it from the documentation. So first of all I will go ahead and import two important package. Okay. One is the RF query run and then you have the Wikipedia query run. Then RC API wrapper and RC sorry Wikipedia API wrapper and RC API wrapper. So this is just like a wrapper on top of that particular tool.

[00:19:13]I will just go ahead and execute this uh because this is what we are specifically going to use as we go ahead. Okay. Everybody clear with this?

[00:19:24]Yeah, everybody clear with this? This is very much simple. I did not do any much things itself but I feel that this is really really simple. Okay, now once I've created this r API wrapper, I will basically go ahead and create a variable API wrapper archiff. I don't know this. I will just disable my extension. Just a second. I hate this co-pilot. I don't know why unnecessary. It'll just go ahead and keep on making all the suggestion which I don't like. Okay. I don't like any kind of suggestion itself. Uh okay. This is my VNV. Perfect. Okay. API wrapper. And then I'm just going to initialize my RC wrapper. And I'm going to say hey probably if you're searching just provide the top k results is equal to two. And then the maximum number of characters that you should return is 500. Okay. So this is the kind of characters that I should be getting over here. And if I want to run it, I will just go ahead and write r is equal to r query run. Okay. Query run with this particular wrapper. And I'll also give a description saying that query RFI papers. Okay. And then I can just go ahead and print RFI dot name. Now here what I'm actually doing is that I'm creating a tools first of all, right? Whatever tools I require.

[00:21:03]Okay, we are just creating that particular tools. So RF is one of the tool that I have. Now similarly, Wikipedia also we have imported over here. So Wikipedia also will be one of the tool. Now let's say that if I want to use this r to do any kind of search how do we do it? So I will write archiff dot invoke invoke and here I will just go ahead and write uh let's say I will go ahead and write attention is all you need. Let's say if I want to search for this particular research paper now it is just going to use this particular tool and this particular providers to probably provide me the response over here. So here you can see attention is all you need u but you don't need all of it for this inference of large language model this paper information everything is provided over here and the maximum characters will be 500 so that basically means my RF tool is working absolutely fine similarly I will do it for Wikipedia also let's say if I want to do the Wikipedia search so Wikipedia API wrapper top results one doc contents max is 500 and similarly Wikipedia query run will create an API wrapper on top of it and this will basically be my tool.

[00:22:09]Okay. Now I hope everybody's clear with this what we have basically done. Can I get a quick confirmation?

[00:22:17]Yeah, please everyone. Yes. Is it interesting? The session is interesting.

[00:22:22]I hope you are able to understand it. I hope you are able to find out things very much easily. Uh just let me know whether you are following each and everything or not. Okay. So just quickly yes it's okay you can search for any paper that you want okay you can you can search for RNN okay what is the latest research on quantum computing just go and search for it okay and here you should be able to get the response fast and efficient nonvolatile the all things are there happy chhatan h I I have a lot of interest. Attention is all you need. But so that is the reason I usually search for all those things. Yeah. Perfect. Now my two tools are ready. Now I need to integrate this in my workflow. That is the most important thing. Right? I need to integrate it. Now the next thing is that I will just go ahead and import OS and call my API key. Okay. So here you can see I have my API key from load.env env load env importing OS OS environment tavly API key OS.get get env tavly API key is just like my internet search. I'm also going to use that specific key. So for this I will just go ahead and write tavly API key and let's go ahead and get it. Okay. So this search API is basically see connect your LM to the web. You can basically get started. I'll just go ahead and login. Once I log in I should be able to get my API key. So I will continue with Google.

[00:24:06]Okay, I'll continue with Google and this is what my API key is. Okay, so I can copy this specific API key and put this in my ENV file. So I will just go ahead and go to my environment variable and here itself I will just go ahead and write it down. Okay, so this basically becomes my Tavly API key.

[00:24:32]Okay, Tavly API is just for my like how duck go search will do. Similarly, internet search tavly API will do. Okay, and then uh what I will do is that I will just go over here. Okay, I will write OS.Evironment T API key get env this this this and we know how to import it, right? So once we do this uh the next step is that uh we are good to go with the uh this this is what I have for my LLM. I will be using the llm that is nothing but from the grock I will use one quen model or any other model that you have. Now since I have already uh imported the tably API key similarly we'll go ahead and create the taby tool right so let me just go ahead and do that again in langin you have something like from lang community tools.tavi Tavly search search import tably search results I have to initialize tably and then once I in execute this okay if I just go ahead and write tabi dot search oh sorry dot invoke okay invoke or let's say I will just go ahead and ask some different question okay provide me the recent AI news. I'll just go ahead and ask this particular question to them. Okay. So, three tools I will try to integrate three tools in my chatbot. So, here you can see I'm getting all the information along with uh you'll be able to see that I'm also getting the link of that particular page that is very very amazing right so this particular page I'm also getting this particular link information each and everything. Okay. I hope till here uh what we have done is that we have created three tools. One is the RFIF, one is the Wikipedia, one is the tably. Okay. And then we go to the next step. Now in the next step what we do we will be combining combining all these tools in the list so that we can integrate with our LLM. Okay. So I'll just go ahead and write hey tools is equal to r, wiki and tavi. Okay. So I have imported all these things. I'll just go ahead and execute this also. Okay. So this tools basically have all the list of tools. Right. Now it's time we will go ahead and initialize our LLM model. So initialize the LLM model. Right. From langchain Grock I'm going to import the gro lm. Sorry not grock lm should be chat grock. Chat grock. Okay. And then I will say hey llm is equal to chat gro.

[00:27:17]I'm initializing my chat gro. And here I will just go ahead and write model is equal to quen. Let's take the recent model that is there right quen 2 billion sorry 2.5 with 3 billion parameters or 32 billion parameters. Okay. So this is the information that I have and this is my LLM that I'm actually going to use.

[00:27:41]Okay. Let's say if I go want to use this LLM and just write dot invoke, I should be able to get the answer. What is AI?

[00:27:49]Okay. So this is my question. So LLM, it is giving me some error. Let's see. The model Quen has been decommissioned. Very good. Okay. So here instead of writing Quen, let me just go ahead and see some more models.

[00:28:09]Okay, I will say I'll think of okay this model. Okay, quen QW 32 billion. Okay, QWQ 32 billion.

[00:28:21][Music] Q QWQ 32 Oh, Q perfect. So this has got executed I think. Yeah. So here you can see I'm getting the response. Let me start by breaking. Think all this information is basically there in the form of AI message. Okay. Now you should know that let's say if I have all the specific tools how do we combine with our LLM?

[00:28:51]That is the most important question.

[00:28:53]Right. So for this what I will do I'll just go ahead and write llm dotbind tools. Okay. And here we are going to specifically go ahead and specify my tools. Right? Once we just write like this, that basically means my LLM will get binded with this tools.

[00:29:10]That basically means the LLM will have the information for this particular tools. Okay. Then I will go ahead and write llmc_ith tools which is my variable.

[00:29:19]Okay, perfect. llm with tools. So I'll go ahead and execute this. And this executes perfectly well. Now in order to execute it, let's execute the call. Okay, what we are looking for if I go ahead and write lm also what is the latest research or let me just change this question. What is what is the recent news uh on AI? Okay, I'll just go ahead and search for this. Now here you can see one very amazing thing very very amazing thing that is happening over here. Okay.

[00:30:02]And you can just see this. Please observe on this. Okay. Here it is not giving me any answer. Instead it is saying hey it is a tool call and the function argument is something like this and we are doing a tably search result.

[00:30:15]See do you see this? It is doing a taby search result JSON. That basically means it knows now if the LLM is making a specific request based on the tools. It is basically telling that it is not directly giving you the output.

[00:30:30]Everybody does it make sense. Yeah. So I have binded LLM with this specific tools. My AI assistant is ready. Now what I will do? I will create the entire application in my langraph and my langraph will be doing that specific task. Does this make sense everyone?

[00:30:47]Yeah. Yes or no?

[00:30:53]Yeah.

[00:30:55]Yes. Can I get a quick yes everyone? Are you following perfectly fine? Is it making sense everybody? Yeah. Can I get a quick yes?

[00:31:10]Are you following all these things? Now you can see I'm not getting the output here. Instead, I'm getting at something called as tool calls because we know that the LLM will not be able to probably answer this. Which tool it is calling? If you see further here you can see tably right taby details is basically given right see model quen this this this tool call everything tably search see result JSON yeah so this is what is basically going to happen right and because of this I think you are now able to understand that hey my LLM is able to understand which tool to call for a specific input Okay. Now the main aim over here is that why it is only for tably because the other tools cannot answer this right. Do you think uh Wikipedia will be able to answer? It does not provide you news, right? Will RC be able to answer? If I go ahead and ask, hey, what is the latest research paper on quantum quantum computing? What should be give me the answer? Tell me. Tell me anyone.

[00:32:24]Anyone what should be who which tool should be giving the answer this one which tool it should call anybody any guesses which tool should it call if I'm asking this question what is the latest research on quantum computing tool right it is very simple so here now you can see tool call function argument quantum computing do you see the name RSF. Beautiful. Right now the LLMA is able to understand and it is able to say hey I know based on your input what tool should I call right now what will happen if I just go ahead and execute this particular sentence. Hey, what is machine learning? Now tell me which tool it will call. Will will it call any tool or whether the LLM will be able to answer it? There is a possibility that it may also call wiki tool or it may directly give you the answer.

[00:33:33]So here you can see that in this particular scenario it is basically calling the Wikipedia I guess Wikipedia. Yeah. And sometime what will happen is that when you keep on executing this the LLM may also give you the answer. Okay. The LLM may also give you the answer. Yeah. Now I hope everybody is able to understand. Yes, I hope you are able to clearly distinguish that how do we bind a specific tools or provider with LLM. And here you can also bind multiple tools.

[00:34:15]Clear? Everybody clear? Let's go with the next step now.

[00:34:24]The next step will be that I will start creating my langraph application.

[00:34:29]Now I will create my entire workflow based on this react architecture that we have drawn. It should start then go to AI assistant. We have to create all this tool node. On this tool node it should basically have this connection with respect to all the tools. Then we have to probably go to the next step. Okay.

[00:34:51]Ready everybody? Yes. Shall we go ahead now? Yeah. Perfect. Now we will try to create the workflow. Now you know that if you have attended my previous class.

[00:35:02]If I want to create the workflow. So first of all I will be importing some of the libraries.

[00:35:08]Right? So let me just go ahead and import some of the libraries like typed dict any message annotated add messages.

[00:35:17]This add messages is basically called as a reducers reducers and lang graph. Okay.

[00:35:25]I will talk about this more as we go ahead. What is the exact usage of reducers? Annotation basically means labeling. Okay, labeling any message basically means it can be either a human message or AI message. Okay. So if I combine both of them or if I combine AI message system message then it can it is a type of any message and type dict is basically for my entire state that I'm actually going to create. Okay. So once I execute this the first thing is that I need to define my state schema and inside my state schema the messages will be the key variable that will be passing through all the nodes. Okay. Now I will just go ahead and create my class state. Then this will be of type dict. Okay, type dict. And here we will be defining something like this.

[00:36:28]This will be nothing but messages is equal to instead of writing list of I will write annotated annotated and this will basically be list of list of any message any message add messages I will talk about this what exactly this basically means okay now here you can see that I am defining a variable that will be available in every node in that particular langraph flow langraph workflow and this is of type annotated list of any message. List of any message basically means this will be nothing but list of all the AI and the system message and the human message it will keep on getting appended. Now how it is basically getting appended because of this particular functionality that is called as add messages. This add messages is basically called as a reducers. Reducers basically means what this is going to do is that it will not override inside this particular variable. Instead it will append messages inside this particular variable. And finally the return type will be in the form of type date. Okay.

[00:37:46]Does this make sense everyone? Yeah.

[00:37:52]Yes. Does this make sense? I hope you are able to understand this. Every parameter we have discussed right annotated list of any messages basically means this will be a list of message with respect to the human interaction the AI interaction the system requirements based on that right and add messages this add messages is a kind of reducers reducers why if I use some other functions over here this messages variable will get overridden we don't need to override it we need to append it so this add messages which we have imported from here which is a reducer.

[00:38:27]It is basically appending it. Okay.

[00:38:32]Clear everyone?

[00:38:34]Yeah. So till here if you are very much clear then we will go ahead with our next step wherein we will just go ahead and create our entire graph. Okay. So now I will go ahead and create my chatbot. Okay. As I said you how many nodes we definitely require over here.

[00:38:52]There are three different nodes. one is start sorry I'll not consider start or end as nodes AI assistant is one of the node tool node is also there okay so I have to probably create this particular node and this node separately okay and then we need to add edges from start to AI assistant AI assistant to tools tools to probably uh tools from tools to we can also end it okay so we will try to create in that specific way okay so here uh first of all we will go ahead and import all these important libraries langraph.graph graph import state graph start end then I am having a tool node which is a pre-built in lang graph and one is tool condition tool condition basically means when should we call the tool node so that is the reason we specifically use tool conditions okay so tool conditions over here is just like if my LLM is calling a tool then what path I need to take if my LLM is not calling a tool what path should I take.

[00:40:00]Okay. So once I execute this, these are the default uh things that we specifically require. Then the next step is that we will go ahead and define our node definition. The first node definition which one this one AI assistant okay so for that I will be using this definition tool calling lm state is equal to state. And here you can see that it is returning LLM with tools. You do you remember what is LLM with tools? LLM with tools is the same LLM bit with tools which we have integrated with all the tools. So this is what we are calling it over here right lm with tools dot invoke state of messages okay state of messages. So state of messages will be having all the messages value and as soon as we write this you can see that we are writing this in the form of a list and because of this particular variable add messages it is just going to append it. Okay clear? Yeah. So this is my one node.

[00:40:59]Okay. Then we go ahead and building the graph. So this uh we will go ahead and build the graph. So for building the graph we will initialize state graph is equal to state. Then we are adding a node. Tool calling lm is nothing but this tool calling llm. And we are adding another node which is called as tool node. This tool nodes tool node right.

[00:41:20]And this tool node is basically uh aligning or we have to just pass all the tools that we have defined in our application.

[00:41:29]Okay, this is very very simple. One is tool calling LLM node. One is the tool node and this tools whatever we have we are passing it inside this. Okay, so this node is one first node is tool calling LLM and the second node is tools. Okay, I'll go ahead and execute this. So this is my lang graph with respect to this. It is ready. Okay. Now the next thing is that we will go ahead and add our edges. So first edge is from from start. So here you can see from start just a second. So here you can see the first edge is from start to tool calling LLM.

[00:42:14]That is this one. This tool calling LM.

[00:42:16]Then from tool calling LLM it will first of all determine see this tool condition will determine if the latest message result from the assistant is a tool call. If it is a tool call the tool condition routes to tool by default. If it is not a tool call then the tool condition routes to end. Okay. So that is the reason we have written tools condition over here. This is my additional conditional edges and tool calling LLM will be making that particular call whether I need to make a call to the tool or whether I should not make to a call to the tool. So my call to the tool is basically over here and it has to probably make this specific tool call. Okay, based on this tool condition, this tool condition is default available over here. See it is a it is a pre-built library and it is basically taking up this specific two steps. Okay. And then finally from the tools we will add this to the end. Okay.

[00:43:11]Right. So first edge is start to tool calling llm then tool calling lm to tools then tools to end. Okay. Now if I want to probably display this graph I will just go ahead and compile it and display it. See do you see this everyone? Amazing right?

[00:43:33]Yeah. Do you see this? See again I'll be repeating. Okay. So first of all what we did we defined our node definition.

[00:43:41]Okay. Inside our node definition I'm calling a tool calling llm. This llm it is nothing but it is just invoking whatever message it is basically getting and it will putting inside this particular messages variable. Okay. Then here you have you can see that I'm building a state graph. I'm adding node tool calling llm with tool calling llm.

[00:44:01]Then my another node is tools which is a type of tool node right and this tool node tools we are passing it inside it as a parameter right so it has references of all the tool providers available right then we are defining our edges okay builder do addage start tool calling llm okay then we are adding conditional edges from tool calling llm if it is a tool call directly tool conditioner will route to tools otherwise it will route to end. Okay. So here you can see that based on this particular tool conditions it will route to tools and if it is routing to tool from tool to end we will be creating one more edge and finally we are compiling it and we displaying this in the form of graph.

[00:44:46]So here you can see this particular graph from start tool calling LLM to tools to end make sense everybody. I hope everybody's able to understand or not.

[00:45:05]Yeah, I will talk about that also.

[00:45:07]Prioritizing tool called LLM MKartic just a second. Everybody's clear with this? Come on. Come on. Tell me guys yeah understood. Now it's time that we will just go ahead and invoke this and see whether this is working or not. Okay. So in order to invoke it, I will just go ahead and write me for messages for graph.invoke Invoke messages human message. Let's see if I give this particular number. What do you think which tool call it should make? This is a research paper number. This is a research paper number. Tell me archive. Right now see the magic.

[00:46:13]Okay. See one thing is very important that you need to understand when we give the input the first input goes to the LLM. The LLM then decides which tool call to make. So here we are making one specific tool call. Okay Rive. Let's say it says Rive. Then R save over here will execute and give you the output and then it will go to end. Okay. Now see this magic. I will execute this. Oh, human message is not defined. I have to import the human message. Just a second. Oh, it's it's okay. If I remove the human message also, it will work. I will just go ahead and execute this. Now, see this by default, this will become a human message only. Do you see? First of all, when I give this particular input with respect to the human message, the AI message, see AI message, why it is saying because this is my AI, right? This is my LLM. See observe this this output is really important for you all to understand. So this is my tool calling LM and this is basically giving you the output right.

[00:47:21]So the AI message says that hey it is a tool call r okay and the argument is nothing but this specific query right then what it goes it goes to this particular tool since it is making a tool call right so this tool is basically going to give you the output name rs published all the information regarding this particular research paper yeah so the output is basically see if output is coming from the tools it is basically a tool message Let's say if I give a message something like this. Let's say I give a message. Hi, my name is Kresh. Let's see now. White it is giving human and AI message. Why it did not hit a tool call? Isn't it amazing? See tell me which which flow it has followed. Now I said hey hi my name is kresh. It got to this tool calling llm and then it went to directly end. Yes or no?

[00:48:34]See AI message and it directly went to end Yashwant Alamuri if you don't know this how what you'll do with MCP. Huh?

[00:48:44]You'll play Katakali.

[00:48:48]H yes Anand you can also have your own tool okay isn't it good see this time I just asked hey hi my name is Kish I did not ask any questions related to any other thing this is my human message AI message basically says that I'm getting the response directly from the LLM here we were getting tool message and we are getting a direct response from tool.

[00:49:23]Understood yes or no. Now I'll ask you one question. You have to give me the answer. Okay. Let's see how much how many of you will be able to give the answer. H I will ask you one question.

[00:49:47]with tell me if I want to create something like this. Tell me what changes I need to do in the graph is very big right I remove this.

[00:50:08]Tell me if I have this diagram then what changes I have to make in the graph. Tell me right now the tool calling LLM is directly calling the tools and going to the end. Now if I need to make this specific changes add conditional edges from tool to tool calling LLM. Amazing.

[00:50:34]Great. Is it so?

[00:50:38]Great, great, great, great, great, great, great. Can I just do something like this? I'll copy this entire thing. I'll paste it over here. Now see this. If I want to create in that way, if I just say, hey, from tools go back to tool lm calling lm. If I make this specific changes, don't you think I'll get the same result? Yes or no? Hey Okay, I have to probably execute it once again. It's okay. I will just restart my kernel and execute it. Okay, but I hope you got an idea, right? This is basically React agent only. See from tool calling llm I have to call back the tools. Okay, so let me just go ahead and execute this again quickly quickly.

[00:51:53]tools quen what is AI [Music] tools. Now instead of calling this particular workflow this is my dictionary this is my this I will just instead of calling this I will call this the below code that I have written. Now see this graph lm tools tool calling l&M to tool calling tool calling why I'm getting this error let's see mermaid link [Music] oho I think this is active that is the reason I'm getting this issue This will execute it. This is giving me an error because I have already displayed one graph. That is the reason I'm getting it. It's okay. What we will do just a second.

[00:53:11]Add another edge to tool calling LLM from tool node. Add tool calling to an end. It's okay. We don't require. See over here tool calling LLM to end it will go automatically. Don't you think?

[00:53:23]Because here it shows that if the latest message for the assistant tool call conditions route to tools, right? So here it will happen that okay now see this magic. Okay. I will just go ahead and search for something like this. Now see my name is Kish and please tell me the see this everyone please everybody see me and please crush my why space is not working so let's execute this once first of Just a second. I have to make some changes. I will make it.

[00:54:31]Okay. Okay. So now if I ask this question, my name is Kish and please tell me the recent research paper on quantum computing.

[00:54:54]Okay. Okay. I'll ask this question. Now see how many questions I have asked.

[00:54:59]I've asked two. My name is Krish and please tell me the research recent research paper on quantum computing.

[00:55:05]Okay. Now based on this diagram just think like how the flow will be. Do you think the two question will be answered at a time or one by one it will be answered and this loop will be very very helpful in that way. First of all, tool calling LLM will take the first context, first sentence context and then it'll think whether I have to make a tool call or not. So let's let's see this. Okay.

[00:55:30]So I'm just going to go ahead and execute this. My name is Kish and please tell me the recent research paper on quantum computing. Let's see how it'll work. So first is the human message. Okay, my name is crush. Then here you can see tool call automatically is basically made. Okay. And it is probably going and finding this, right?

[00:55:53]So this is a problem out here. Okay. The reason why it was not able to answer and let me make this particular question change. Okay. I'll say hey um let's say what is the recent AI news and then please tell me something. Okay. I I'll ask this question. Let's see how it will probably give me the answer. Okay.

[00:56:17]What is the recent AI news? and then please tell me the recent research paper on quantum computing. Okay, do you see what is the recent AI news and then please tell me the recent uh recent research paper on quantum computing. So first it made this tool call. Do you see this RFIF tool uh sorry Tavly search tool call? Yeah. And then you can see I got this particular response from Tavi right. Then do you see I got a RIFF call.

[00:56:48]Yeah, the first thing was that it took the first sentence what is the recent AI news, right? And it did this stavly search. Now see observe with respect to this particular flow. I gave a longer sentence which had two different sentence out there. One was hey provide me probably the recent AI news and then tell me about the recent research paper on quantum computing. Okay now see the magic. So first of all the tool calling LLM is saying that hey I have to first of all handle this first sentence. So what it did based on this human message it made this specific tool call and it got this particular out output from the travely search J uh uh result JSON right then this next sentence continuation is happening. Now tell me where this should request should go whether it should go to RV or Tavi where it should go archive right so it made an archive call and finally this is basically your response yeah making sense yes or no everyone how happy we are you with the session and this is The framework that we have followed over there a react framework react basically means this will reason first of all a reasoning will happen and then the acting will happen yeah happy with the explanation and this is just one thing because I'm feeling that I'm I'm thinking that in the next session I will talk about MCP also how you can probably replace this entirely with MCP and what are the advantage that you specifically get with MCP right? Make sense everyone? Yes, it traverse one tool to the other tool. Right? It is jumping from one tool to the other tool.

[00:58:56]Yeah, sir. What are the prerequisites?

[00:58:59]See guys, again I'm telling you uh for this you definitely need to know Python programming language at least you know then you should be able to understand and all this specific stuff.

[00:59:12]I will be putting all this particular code in the registered link in given in the description either it may be in LinkedIn or YouTube just go ahead and see that and uh if you also want to join uh we are we are starting our batches recently uh two one live batch we are basically starting which is nothing but Agentic AI and uh this particular batch is nothing but if you probably go ahead and see the course detail syllabus like just go to krishnag.in in click on live classes and here you'll be able to see that live aentk and genetic AI application boot camp okay and if you go over here if you click on enroll now this is the page that you're going to go ahead you know so here we are going to probably take about each and everything so let me just open this again okay so here we are going to cover each and everything that is required for agentic genai and MCP with cloud boot camp all the information you'll be able to find out in the description of this particular video here. Our main aim is basically to show you how to build this kind how to use multiple frameworks like lang graph, lang chain, creai. We are also going to use different frameworks uh different techniques MCP everything is basically going to get covered over here. Okay. And uh if you are interested just go ahead and take this uh if not yes free sessions are obviously there which I will be obviously covering things out there. Okay. Mohammad says that sir please give some discount. We are not working professionals. Ham just call the counseling team that is provided in the description. They will definitely help you out for the students. Okay. For students there are good discounts that our team gives and uh based on that you can just talk to them. I don't know like what discounts are running over here. My main aim is basically to cover as much as syllabus that I can.

[01:01:00]Right. Uh change the edge. Which edge sir? Uh Anand yeah superb thank you go and check all the information is given in the description if you know want to know more about this particular batch but this batch is something like uh I will be starting we'll be talking about langra pidentic and all prerequisite is that you need to know python programming language at least okay then you're good to go ahead because here we are focusing on building applications okay sir I have one question is opensource LLM used in industries on production. Yes, you can use it. Okay.

[01:01:39]But again, it depends on the company's requirement whether you want to probably deploy it in the local or not.

[01:01:46]Yeah. So, how was the session overall everyone? Good. Did you like it? Yeah. Yes or no? Yes.

[01:02:08]Can I give the prompt to give the order of execution tool? Sometimes in my query need to use two tools. Yes, sometime three. Yes, you can give. As you give the question based on that the tools call will happen, right? Do you want me to continue this kind of live sessions? Guys, please do hit like. Obviously, that is required for my motivation.

[01:02:29]But I hope you like this particular session and uh you are able to understand each and everything.

[01:02:38]Okay. Yeah. Any questions that you have, I'll be happy to take it for the next 5 minutes.

[01:02:46]Yep. Then we'll take the more live session in the later stages. I'll try to integrate uh something like MCP also once I get time.

[01:02:58]Will I get a recorded version of this session? Yes, Sanjay, it is already it'll be available in YouTube in my live sessions. Can we connect LLM without frameworks? I mean through prompts you can do it but uh using frameworks will be a best way. Okay, perfect. Uh guys, thank you for attending this particular session.

[01:03:26]Um this was it. So where can I access the source code? Uh I will be giving in the description there is one registration link which you can go ahead and register. It is completely for free.

[01:03:38]Langraph and lang lang chain are related or different from each other. See lang chain is overall the company name.

[01:03:45]Langchain library is also there.

[01:03:46]Langraph is specifically used to create more complex workflows.

[01:03:52]Okay. Okay. Perfect. So thank you everyone.

[01:03:57]Uh this was it. Uh I hope you like this.

[01:04:02]Other than that if you want to probably join any sessions and yes uh in Udemy also if you want to buy any course there is a coupon code April02 which you can get courses in 399. You can go ahead and refer it out. Okay. So thank you everyone. Uh I hope you like this particular session. This was it from my side. I'll see you all in the next session. Have a great day. Thank you and all. Take care. Bye-bye. Bye-bye everyone. Okay. Uh, will there be any session regarding modular wise on Genai?

[01:04:31]Yes, Melvin. We will be having as we go ahead. I'll be developing that also.

[01:04:35]Okay. Thank you. Thank you everyone. Bye-bye. Have a great day.

Up Next

LangGraph Agents: Implementing Human-in-the-Loop with User Feedback

@LangChain

25.5K views•2024-07-11

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

HTTP Requests Explained: GET, POST, PUT, DELETE

@codecademy

103.1K views•2021-10-07

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap