This article walks through the design and implementation of a multimodal Retrieval‑Augmented Generation (RAG) system using LangChain 1.0, detailing a front‑end/back‑end separated architecture, FastAPI service setup, multimodal data handling, conversation history management, streaming responses, and Postman testing to verify the intelligent Q&A module.
This article walks through setting up MCP servers in both stdio and SSE modes, shows how to load their tools into LangChain agents using the new create_agent API, compares the two communication methods, and provides complete runnable Python examples.
This guide dives into the four advanced capabilities of LangChain 1.0's create_agent API—MCP tool integration, structured output, memory management, and middleware—showcasing practical examples such as an Amap MCP planner, Pydantic‑based response formatting, InMemorySaver chat history, and custom middleware for dynamic model selection.
This tutorial walks through setting up a Python environment, explains the three essential components of LangChain 1.0’s create_agent API, details the built‑in message types, and demonstrates four streaming output modes using a weather‑assistant example to help developers quickly adopt the new agent framework.
This guide walks through LangChain 1.0’s three major upgrades— the new create_agent API that replaces legacy agent builders, standardized content_blocks for unified model output, and a streamlined package structure—while showing how middleware hooks, built‑in and custom middleware, and improved structured output simplify production‑grade AI agent development.
LangChain’s stateless LLMs require a memory component to retain conversation context, and this article explains the importance of memory, compares built‑in memory types, and walks through two practical examples—custom buffer memory and basic message history—showing how to implement and use them with code.
LangGraph extends LangChain by letting developers define stateful, multi‑agent LLM workflows as graphs with nodes, edges, and shared state, and the article walks through core concepts, typical use cases, and a detailed example that shows how to define state, nodes, edges, compile and run the graph.
This guide explains what LangChain toolkits are, why they simplify building domain‑specific AI agents, lists common built‑in toolkits, and walks through the step‑by‑step process of instantiating a toolkit, retrieving its tools, and creating an OpenAI‑powered agent, illustrated with a SQL database example.
This guide explains how LangChain’s Expression Language (LCEL) lets you declaratively connect prompts, models, and output parsers into chains, walks through environment setup, dependency installation, and detailed code examples ranging from a basic joke generator to retrieval‑augmented generation and memory‑enabled agents.
Learn how LangChain enables multimodal interactions by preparing inputs, constructing prompts, invoking models like GPT‑4o, and processing responses, with a complete example that demonstrates image‑question answering, code walkthrough, environment setup, and key considerations for API keys and image URLs.
This guide explains what LangChain tools are, why clear descriptions matter, and walks through three ways to create them—using the @tool decorator, StructuredTool with Pydantic models, and custom BaseTool subclasses—plus examples of built‑in tools and reference links.
This article explains the core concept of LangChain agents—combining an LLM, a set of tools, and a reasoning‑action loop—to enable dynamic decision‑making, tool invocation, and iterative observation for solving complex, multi‑step tasks.
Building AI agents may seem straightforward with frameworks like LangChain, but hidden complexities in orchestration, memory management, reproducibility, and scalability turn simple demos into fragile systems, requiring systematic engineering, observability, and robust design to achieve reliable, production‑grade intelligent agents.
This article provides a detailed analysis of LangChain's OpenDeepResearch project, comparing its Graph workflow and Multi‑Agent architectures, explaining core node implementations, execution flows, and offering step‑by‑step instructions for configuring and deploying the system locally.
This article explains how LangChain's Indexing API adds state management and synchronization to the classic load‑split‑embed‑store RAG pipeline, detailing the RecordManager component, the index function workflow, key parameters, implementation considerations, and best‑practice code examples for production‑grade vector stores.
This article explains the concept of LangChain retrievers, compares them with vector stores, and provides step‑by‑step code examples for MultiQueryRetriever and EnsembleRetriever, showing how to boost recall and combine semantic and keyword search for robust RAG pipelines.
This article presents a structured, step‑by‑step learning path that guides beginners from Python fundamentals through AI API mastery, Retrieval‑Augmented Generation, deep MCP protocol knowledge, and advanced multi‑agent development, complete with practical code examples and performance‑monitoring techniques.
This article walks developers through three essential upgrades for Retrieval‑Augmented Generation systems—hybrid search combining vector and keyword retrieval, query rewriting to clarify conversational inputs, and re‑ranking with a cross‑encoder—providing step‑by‑step code examples using LangChain to dramatically improve answer quality.
This article explains what vector stores are, outlines their core workflow of adding, querying, and searching embeddings, compares popular back‑ends like FAISS, Chroma, and Pinecone, and walks through a complete Chinese‑language example using LangChain’s FAISS integration with detailed code and result analysis.
This article explains what embeddings are, how LangChain’s Embeddings interface abstracts various providers, compares common models, and walks through a complete Python example that uses a Chinese‑optimized HuggingFace model to generate document and query vectors, compute cosine similarity, and identify the most relevant text.
This article walks through the design and implementation of a multi‑agent DeepResearch application using the Pipeline‑Agent pattern with LangGraph and LangChain, detailing three agents for task planning, web search via Tavily, and report generation, and provides complete Python code and test results.
This guide explains why large documents must be broken into semantic chunks for LLMs, introduces core parameters like chunk_size and chunk_overlap, compares LangChain's various splitters, and walks through a complete Python example that loads a long text, configures a RecursiveCharacterTextSplitter, and inspects the resulting chunks.
This tutorial shows how to let large language models autonomously invoke external services—specifically a MySQL database—by using the Model Context Protocol (MCP), covering environment setup, MCP service implementation, agent integration, and real‑world execution results.
The article examines the shift from single-model calls to autonomous AI agents, outlines the seven most influential AI agent frameworks for 2025—including LangChain, LangGraph, CrewAI, AutoGen, and Semantic Kernel—compares their core strengths, learning curves, and ideal use cases, and offers a practical selection guide for developers and enterprises.
This comprehensive AI agent development course covers 18 chapters, ranging from fundamental concepts and architecture to large‑model integration, tool and browser control, memory, RAG self‑learning, sandboxing, database manipulation, multi‑agent architectures, code assistance, and a real‑world frontend automation project, complete with source code and documentation.
Learn how to use LangChain's Document Loaders to import data from files, web pages, databases, and APIs, understand the Document object structure, compare load() versus lazy_load(), and follow a step‑by‑step Python example that demonstrates loading, inspecting, and optionally processing documents with an LLM.
The article explains that successful AI Agent deployments require a multi‑layered architecture—model, framework, and tool layers—detailing how LangChain, LangGraph, and MCP work together, and provides concrete implementation steps, best‑practice recommendations, and a roadmap from a minimal agent to an enterprise‑grade system.
This guide explains why custom output parsers are needed for LangChain when dealing with non‑JSON or XML responses, walks through inheriting BaseOutputParser, implementing parse() and optional format instructions, and provides a complete Python example that converts a simple "Key: Value" string into a dictionary.
This article explains why LLMs output plain text, introduces LangChain output parsers as the bridge to structured data, details their workflow, reviews built‑in parsers, and walks through a complete Python example that builds a prompt‑model‑parser chain to generate a JSON‑based joke.
The article explains why few-shot prompting benefits from dynamically selecting a small set of relevant examples, introduces LangChain’s ExampleSelector component, compares three selector strategies—LengthBased, SemanticSimilarity, and MaxMarginalRelevance—detailing their algorithms, advantages, drawbacks, and provides step-by-step Python code demonstrations for each.
This guide explains how LangChain structures interactions with chat models using role‑based Message objects—HumanMessage, AIMessage, SystemMessage, ToolMessage, and others—detailing their purposes, code examples, and how they enable multi‑turn AI agent workflows.
This guide explains how to use LangChain's ChatPromptTemplate and MessagesPlaceholder to construct multi‑turn, memory‑aware chatbots, detailing core message templates, dynamic history insertion, and multiple creation methods with concrete Python code examples.
This article categorizes and compares twelve popular large‑model AI Agent development frameworks—low‑code platforms, basic programming paradigms, advanced code libraries, and multi‑agent systems—detailing their core features, typical use cases, and trade‑offs to help developers choose the most suitable solution.
This article explains why prompt templates are essential for LLM interactions, compares LangChain's PromptTemplate and ChatPromptTemplate, and walks through a complete Python example that prepares the environment, builds reusable templates, formats messages, and integrates them into an LCEL chain for chat models.
This article explains why and how to create custom LLM and chat model wrappers in LangChain by inheriting base classes, implementing core methods like _call and _generate, and demonstrates a full example with an echo‑based chat model, including streaming support and testing benefits.
This article explains how function (tool) calling lets large language models like GPT or Gemini invoke external APIs, walks through defining tools with LangChain, and demonstrates a complete Python example that fetches real‑time weather data and returns a natural‑language answer.
This article explains LangChain's two core abstractions—LLM for simple text completion and ChatModel for multi‑turn conversational AI—detailing their input/output formats, practical code examples, and why ChatModel is generally preferred for modern dialogue applications.
Learn how to serialize LangChain components—including prompts, chains, and agents—using JSON and YAML, enabling reproducibility, collaboration, persistence, and decoupling, with step‑by‑step code examples for dumping objects to files and loading them back into executable LLM pipelines.
LangChain’s callback system lets developers hook into every stage of an LLM chain— from chain start/end to token generation—using built‑in handlers like StdOutCallbackHandler or custom handlers derived from BaseCallbackHandler, with examples showing constructor‑level and request‑level attachment, plus a custom handler implementation.
This article explains how LangChain’s RunnableParallel component enables true parallel execution of independent sub‑tasks, walks through concrete Python examples, compares serial versus parallel runtimes, and outlines when and why to apply this pattern for faster, more capable LLM applications.
An in‑depth guide compares LangChain, LangGraph, and LangSmith—the three specialized layers for LLM app development—detailing their core architectures, ideal use‑cases, and how to select the optimal combination, illustrated with a real‑world iPhone 17 refund workflow example.
This guide walks you through installing the LangChain library, adding model‑specific packages, verifying the setup with a Python script, configuring API keys via environment variables or a .env file, and preparing to use OpenAI‑compatible models such as DeepSeek or Qwen.
This repository offers a comprehensive, step‑by‑step LangChain tutorial series that walks developers through installation, the LangChain Expression Language, streaming, parallel execution, callbacks, serialization, model customization, prompt templates, memory, multimodal support, and advanced tools like LangGraph and LangSmith, enabling the creation of sophisticated AI applications.
This article compares LangChain, LangGraph, and LangSmith—three complementary frameworks for building LLM-powered applications—explaining their distinct architectures, use cases, and features, and also introduces related concepts such as RAG, MCP, A2A protocols, hierarchical memory systems, context engineering, and knowledge graphs to guide developers in selecting and integrating the appropriate tools.
This article compares low‑code development platforms with open‑source large‑model frameworks such as LangChain and LlamaIndex, outlining their features, advantages, limitations, and suitability for building retrieval‑augmented generation (RAG) applications in various enterprise scenarios.
The article examines how rapid advances in generative AI have transformed enterprise AI Agent development, comparing evolving frameworks like LangChain, Semantic Kernel, and Spring AI with emerging low‑code platforms such as Dify and Copilot Studio, and outlines architectural challenges, integration strategies, and best‑practice design principles for Java‑centric organizations.
This article explores Browser-Use, an AI‑driven browser automation framework that combines large language models, visual perception, and DOM analysis to enable intelligent, multi‑step web tasks such as registration, price comparison, form filling, and monitoring, while detailing its architecture, historical context, core modules, and future challenges.
This article chronicles the author's hands‑on journey of designing AI agents to automatically generate Helm charts for open‑source applications, exploring agent role definition, behavior paradigms like ReAct and plan‑and‑execute, prompt engineering challenges, structured workflows, multi‑agent collaboration, and practical lessons for reliable, production‑grade automation.
The article compares LangGraph with LangChain, explains why a graph‑based architecture offers greater flexibility than linear chains, outlines LangGraph’s three‑layer core architecture and its ecosystem tools—including LangSmith, LangGraph Studio, CLI, and Agent Chat UI—while noting its reliance on LangChain and the need for VPN for CLI usage.
After weeks of trial‑and‑error, the author shares how a fully autonomous AI agent struggled to generate Helm charts, and how adopting a structured, multi‑stage workflow—combining clear role definitions, ReAct/Plan‑and‑Execute patterns, prompt engineering, and LangChain/LangGraph orchestration—produced a reproducible, lint‑validated Helm package for Kubernetes.
This article provides a step‑by‑step technical guide to optimizing Retrieval‑Augmented Generation (RAG) for interview scenarios, covering query rewriting, HyDE, fallback strategies, routing and prompt routing, multi‑representation indexing, hybrid retrieval, re‑ranking, self‑RAG, generation control, performance benchmarking, and a practical checklist with concrete code examples and metrics.
This article examines the evolution of LangChain's Open Deep Research project from a monolithic LLM pipeline to a multi‑agent system, highlighting the role of context engineering, architectural trade‑offs, practical code examples, and best‑practice guidelines for building scalable, token‑efficient AI solutions.
This article presents a systematic study of extracting knowledge graphs from unstructured news articles using small quantized LLMs, exposing the brittleness of LangChain's JSON‑based pipelines, evaluating prompt‑engineering fixes, and introducing the BAML framework whose fuzzy parsing and concise schema raise extraction success from roughly 25% to over 99% on a 344‑document benchmark.
This tutorial shows how to create a lightweight Retrieval‑Augmented Generation (RAG) system that indexes multiple PDF files, stores their embeddings in a FAISS vector database, and answers user queries through a LangChain agent powered by DashScope embeddings and the DeepSeek‑Chat model, all wrapped in a Streamlit UI.
This tutorial walks through the complete process of connecting LangChain to a Model Context Protocol (MCP) server, covering environment setup, configuration files, client code, and a PlayWright‑based browser automation example that demonstrates building and running an AI agent with LangChain.
This article walks through constructing an agentic RAG pipeline that combines LangChain, LangGraph, Google Gemini embeddings, and Qdrant vector storage to enable automatic query rewriting, relevance grading, and concise answers to blog‑post questions via a Streamlit UI.
This tutorial walks through using LangChain's Agent API to create AI agents with tool calling, demonstrating a weather‑assistant example, parallel and sequential tool calls, and integration of the Tavily search tool, all with concise Python code and step‑by‑step explanations.
This article walks through how to integrate LangChain's built‑in tools and user‑defined functions into AI agents, covering environment setup, installing dependencies, using the Python code interpreter tool, binding tools to a model, parsing tool calls with JsonOutputKeyToolsParser, and demonstrating both a data‑analysis example and a weather‑lookup function.
This article explains how to create a RAG‑based intelligent QA system that fetches the latest documentation (e.g., PlantUML) before querying Gemini, detailing knowledge‑base creation, embedding, vector store management, LangChain integration, and deployment tips.
This tutorial revisits LangChain basics, demonstrates how to add multi‑turn memory to a chatbot, shows streaming output via the stream method, and walks through creating a full‑stack web interface with Gradio, providing complete Python code examples for each step.
This article demonstrates how to rapidly create a full‑stack Agentic Retrieval‑Augmented Generation (RAG) application using Alibaba Cloud RDS PostgreSQL‑based Supabase, covering data preparation, vector storage, real‑time communication, authentication, deployment steps, performance optimizations, and code examples with LangChain and large language models.
This tutorial walks through LangChain's core concept of Chains, demonstrating how to build simple, composite, and custom node chains, use prompt templates and structured output parsers, and leverage the LCEL syntax for clean, modular LLM applications.
This article explains how the open‑source browser‑use framework combines carefully designed SystemMessage prompts, structured HumanMessage inputs, and LangChain‑driven tool calls to enable large language models to automate complex web tasks such as shopping, CRM updates, résumé processing, and document generation, while providing concrete code examples and best‑practice tips.
This tutorial explains LangChain's core modules and three‑layer architecture, shows how to set up a Python environment, and provides concrete code examples for connecting SiliconFlow Qwen3‑8B and DeepSeek models via the init_chat_model API, including result inspection and references to official documentation.
This article introduces AI Agents and explains why LangChain is the leading framework, detailing its core concepts, three‑layer architecture, key features, comparison with other agent frameworks, and showcasing popular projects built with LangChain and LangGraph.
This tutorial walks through creating a full‑featured LLM Agent workflow using LangGraph, covering goal definition, task decomposition, execution nodes, state updates, re‑planning logic, and user feedback, while comparing ReAct and Reflexion approaches and providing complete Python code examples.
This tutorial walks through the fundamentals of large language models, prompt engineering, word embeddings, and shows how to use the LangChain framework (including its Java implementation LangChain4j) to build, memory‑manage, retrieve, and chain AI‑driven applications with practical code examples.
This tutorial walks through the limitations of linear LangChain workflows, introduces LangGraph’s state‑node‑edge architecture, and provides step‑by‑step code examples—including a Hello‑World tool, conditional branching, multi‑turn conversation handling, and graph visualization—so readers can construct robust, persistent LLM agents.
In a candid conversation, Andrew Ng and Harrison Chase explore the evolving landscape of AI agents, discussing modular toolchains, the emerging MCP standard, challenges of agent‑to‑agent communication, voice interaction latency, and the importance of rapid, technically skilled execution for successful AI product development.
This tutorial shows how to install LangGraph and MCP Server, define math and weather tool nodes, connect them via a MultiServerMCPClient, and build a ReAct agent that demonstrates tool‑calling workflows, including handling missing functions and HTTP‑based services.
This article provides a comprehensive overview of generative AI agents, detailing their core components—model, tools, and orchestration layer—explaining cognitive architectures, tool types, learning strategies, and practical development with LangChain and Vertex AI, while highlighting future prospects and challenges.
This guide walks through the complete process of creating a RAG‑powered question‑answering bot using LangChain, Streamlit, and vector‑store embeddings, covering theory, architecture, data loading, chunking, vector indexing, retrieval, LLM integration, and full code implementation with practical examples.
This article surveys the evolution of AI applications, explains large language model fundamentals, outlines architectural challenges, and introduces three core patterns—Retrieval‑Augmented Generation (RAG), autonomous Agents, and Model Context Protocol (MCP)—while providing practical LangChain code snippets and integration guidance.
In his Interrupt 2025 keynote, LangChain founder Harrison Chase outlines the four core skills required of modern “Agent Engineers,” explains why multi‑model architectures, prompt‑driven context, and cross‑functional teamwork are essential, and reveals how LangGraph, LangSmith and the Open Agent Platform aim to solve current deployment and observability challenges for production‑grade AI agents.
This article explains how to construct a financial question‑answering agent that automatically decides between SQL queries and RAG retrieval, covering intent recognition, tool creation, prompt design, agent initialization, and end‑to‑end testing with Python code.
This article walks through the complete installation and configuration of Suna, an open‑source, fully offline AI agent built on Claude 3.7, LangChain, and Daytona, comparing its richer UI and privacy advantages to Manus, and demonstrates its capabilities by automating a Kaggle competition analysis.
This article explains why Retrieval‑Augmented Generation (RAG) is essential for AI‑driven customer service, outlines the limitations of large language models, details the three‑stage RAG workflow (indexing, retrieval, generation), and shows how to implement it with FastGPT, vector databases, and LangChain.
DeerFlow, an open‑source deep‑research platform built on LangStack, showcases a novel multi‑agent architecture, Meta‑Prompt engineering, MCP integration, and AI‑generated podcasts, providing developers with a powerful, extensible framework for advanced LLM‑driven workflows.
This tutorial walks through building a Retrieval‑Augmented Generation (RAG) system by combining LangChain for document processing, Elasticsearch’s vector store with the ELSER v2 model for semantic search, and Higress as a cloud‑native AI gateway, complete with deployment scripts, code examples, and query testing.
This guide explains the Model Context Protocol (MCP), compares six Python and TypeScript AI frameworks that implement MCP, demonstrates their architectures, registries, and code integrations—including OpenAI Agents SDK, Praison AI, LangChain, Chainlit, Agno, and Upsonic—while also discussing the benefits, challenges, and future standardization of MCP in AI agent development.
This article introduces LangGraph, the next‑generation framework built on LangChain for constructing complex, stateful AI applications, compares it with LangChain, showcases real‑world deployments, and provides a step‑by‑step Python tutorial for building a smart customer‑service chatbot with looped reasoning, tool integration, and human‑in‑the‑loop support.
This article walks through the overall design, implementation, and troubleshooting of a web‑based MCP client and server using CopilotKit, LangChain, Next.js, and related TypeScript libraries, covering setup, core code, environment configuration, and deployment steps.
This article explains Python decorators—how they wrap functions to add behavior without modifying the original code—provides clear syntax examples, a practical timing decorator, a class‑diagram illustration, and shows how the @tool decorator integrates functions into LangChain agents.
This tutorial walks through the concept of PromptTemplate in LangChain, demonstrates how to build chat prompt templates, use message placeholders, apply Few‑Shot prompting and ExampleSelector techniques, and shows concrete code and output examples that help mitigate large‑language‑model hallucinations.
This article explains the open‑source Model Context Protocol (MCP) created by Anthropic, describes its client‑server architecture for safely linking LLMs with external data sources and tools, and provides a complete step‑by‑step Python tutorial—including environment setup, server and client code—to demonstrate MCP in action.
This tutorial walks through the limitations of simple prompt usage, introduces LangChain as a framework for building full‑featured LLM applications, explains its core concepts and components, and provides step‑by‑step code examples for installing, configuring, and running a basic LangChain demo.
This tutorial explains the fundamental differences between AI workflows and autonomous agents, compares their strengths, outlines when to use each approach, and provides concrete LangChain/LangGraph code examples, framework references, and best‑practice recommendations for building reliable LLM‑powered systems.
This tutorial introduces the fundamentals of LangChain, explains large language models, prompt engineering, word embeddings, and demonstrates how to use the Java implementation LangChain4j with Maven dependencies, model I/O, memory, retrieval, chains, and agents to build sophisticated LLM‑driven applications.
This tutorial shows how to build a LangChain pipeline that uses GPT‑4 Vision to read vehicle images, defines a Pydantic model for type, license, make, model and color, and returns the results as structured JSON for both single and batch inference.
The article explains why LLM responses can be inconsistent, introduces Pydantic as a way to define custom output schemas, and walks through concrete examples—both with OpenAI and Ollama models—showing how to build a LangChain pipeline that parses responses into structured data.
This article explains how agentic frameworks transform AI development by enabling autonomous, reasoning systems, compares leading open‑source options such as LangChain, LangGraph, CrewAI, Microsoft Semantic Kernel, AutoGen, Smolagents and Phidata, and provides a step‑by‑step LangGraph tutorial with code examples and a comparison table.
A comprehensive analysis of AI agents draws on a LangChain survey of over 1,300 practitioners, revealing high adoption intent, key use cases, challenges in performance and control, and deep dives into planning, UI/UX, and memory architectures, supplemented by case studies and a 2025 outlook.
This guide walks you through Milvus 2.5’s new full‑text, keyword‑matching, and hybrid search capabilities, showing how to set up the schema, install dependencies, prepare data with LangChain, and combine dense and sparse vectors for RAG‑enabled retrieval using Python.
This guide explains how to configure and import the appropriate DistanceStrategy in LangChain, compares Euclidean distance, maximum inner product, and cosine similarity, and outlines their formulas, advantages, and typical use‑cases for vector‑based retrieval.
DeepSeek‑R1 excels at deep reasoning but lacks native structured output; this guide explains why structured output matters, outlines common API‑level techniques, and provides three practical solutions—using an auxiliary model with a LangChain chain, a LangGraph workflow, and a ReAct agent—complete with code snippets and JSON‑mode tips.
This article walks through setting up a local Retrieval‑Augmented Generation (RAG) system using the open‑source DeepSeek‑R1 model run via Ollama, covering installation, model selection, PDF ingestion with LangChain, semantic chunking, FAISS vector store creation, RetrievalQA chain construction, and a Streamlit UI for querying.
This guide walks you through installing Ollama, pulling the open‑source DeepSeek R1 model, and using LangChain and Streamlit to create a locally hosted Retrieval‑Augmented Generation (RAG) system that can answer questions from uploaded PDFs without any cloud API.
The article outlines how to build a scalable, modular AI code‑review agent using LangChain, detailing stages from naive prompting to advanced prompt engineering, architecture with six core modules, strategies to curb hallucinations, improve reliability, performance, and human‑AI collaboration, and future RAG integration.
The article surveys the rise of multi‑agent LLM systems, detailing how specialized agents collaborate on tasks such as travel planning, outlining their workflow, comparing them with single‑agent models, listing prominent frameworks, and discussing current challenges and research citations.
Retrieval‑Augmented Generation (RAG) using LangChain lets developers enhance large language models by embedding user queries, fetching relevant documents from a vector store, inserting the context into a prompt template, and generating concise, source‑grounded answers, offering low‑cost, up‑to‑date knowledge while reducing hallucinations and fine‑tuning expenses.