Agent Development Learning Path: A Complete Guide to LangChain and LangGraph in Practice

Many developers feel overwhelmed when they encounter terms like LangChain, LangGraph, and MCP in Agent development, mistakenly believing each new concept requires learning an entirely new stack from scratch. In a hands-on course on Bilibili, the creator "复返AI" (Fufan AI) lays out a clear relationship: LangChain provides the common capabilities for building Agents, LangGraph orchestrates the task execution flow, and MCP is the protocol for connecting to external systems. Only by working together can the three efficiently produce Agents that actually get work done. Based on that course, this article organizes a complete learning path from model and tool integration to multi-agent collaboration.

The Relationship Between the Three Core Concepts: Stop Reinventing the Wheel

According to the explanation by Bilibili creator "复返AI," LangChain is a framework for developing large-model applications. It organizes common capabilities—integrating models, configuring tools, and deciding the next step based on tool return values—so developers don't have to write everything from scratch each time. For example, to build a research assistant, the model understands the query intent, the retrieval tool finds the material, and LangChain helps string them together into an Agent that can execute tasks.

LangGraph is also a development framework, but it focuses more on the task execution flow. A task has several steps: which are done in sequence, which can be done simultaneously, under what conditions to return to a previous step, and where the process must stop and wait for human confirmation—all of this can be organized with LangGraph. For the same research assistant: after gathering material, a report must be written; the report must pass review before it is sent; if it fails review, it goes back for revision—this is the flow managed by LangGraph.

The relationship between the two is one of collaboration: LangChain provides the common Agent-building capabilities, and its Agent underlying implementation also uses LangGraph; when you need to carefully arrange execution steps yourself, you can use LangGraph directly for orchestration. MCP, meanwhile, is a connection protocol that solves the problem of "how to connect to external capabilities"—if a certain data system provides an MCP service, then a client that supports MCP can connect to the tools and data it exposes according to a unified specification. As for what to do specifically and in what order, that is still determined by the Agent and the workflow.

MCP (Model Context Protocol) is a connection protocol proposed and open-sourced by Anthropic at the end of 2024, aimed at providing a standardized communication specification between AI applications and external data sources and tools. Before MCP appeared, every time an external system (such as a database, CRM, or file system) was integrated, developers often had to write separate adapter code for it, creating a large amount of repetitive and hard-to-reuse "glue layer." MCP abstracts these integration approaches into a unified client-server model: external systems expose their tools and data resources in the form of an MCP Server, while the Agent side calls them through a client that supports MCP according to a unified interface. You can think of it as the "USB interface standard" of the AI application world—as long as both sides follow the protocol, connecting no longer requires custom development. Note that MCP is only responsible for "whether you can connect and how to connect"; it does not determine the Agent's business logic and execution order, which are still handled by LangChain/LangGraph.

Environment Setup and the Core API: Create Agent Is the Code You Must Master

The course demonstrates the basic installation and deployment of LangChain. These days the V1 version of LangChain is commonly used, requiring Python 3.10 or above. It is recommended to use UV to create an isolated Python virtual environment, which is lighter, more flexible, and easier to maintain than Conda. During installation, you need to install LangChain, LangGraph, and the corresponding model integration packages together—for example, LangChain DeepSeek^Ad is specifically for integrating the DeepSeek model, and there are also third-party integration packages such as OpenAI, which can be installed as needed.

After configuring the API Key, the course focuses on explaining the core API create_agent. For the major LangChain 1.0 release, it encapsulates the core parts of Agent development in a single API: you can set the model, load all the tools you want to give the Agent in the Tools list, and then pass in the System Prompt. From the lowest-level perspective, the core of an Agent is the model, tools, and system prompt, and create_agent merges these elements together reasonably and stably. When you converse with the Agent in the future, the underlying process is calling the model, enabling tools as appropriate, and following the System Prompt to complete the response.

The creator emphasizes that this code is a must-master; other technical details can be left to AI coding assistants, but you must understand how the Agent's most core underlying API is implemented.

Agent Loop: The Underlying Principle of All Complex Agents

After the installation and invocation sections, the course delves into the Agent Loop, the basic concept of the Agent runtime. The core function of a simple Agent is to repeatedly call tools in a loop until the user's problem is solved: after the user's question is input, the model judges whether a tool needs to be called; after the call, the result is returned to the model; the model then checks whether the result can solve the problem—if so, it replies to the user; if not, it continues calling tools.

The creator points out that many complex Agents—for example, Cloud Code, which may call tools dozens of times and run for a long time—still use this Agent runtime architecture at the bottom; it's just that in complex cases, the big loop contains smaller loops, sometimes even three levels of loops. Understanding the Agent Loop is very useful for subsequent development.

The course demonstrates with a dataset from an intelligent customer service scenario, defining functions such as order query, logistics tracking, shipping cost calculation, and inventory query as an external tool set, and then using create_agent to associate these tools. In the demonstration, when a user asks about order status, the Agent calls the query tool and returns the result; when the user poses a composite question like "check the logistics status and calculate the shipping cost of a 1.5 kg item from Beijing to Shanghai," the Agent calls two tools in parallel, queries them separately, and finally aggregates the results.

When understanding the Agent Loop, a key concept is Tool Calling / Function Calling. It means that when generating a response, the large model does not directly output a natural-language answer; instead, it outputs a structured call request specifying which function to call and what parameters to pass. After the Agent runtime receives this request, it executes the corresponding real function (such as querying the order database), then sends the return value back to the model as a new message, and the model continues reasoning based on it. It is precisely this mechanism of "model outputs call intent—external execution—result returned" that allows the model to break through the limitation of answering only from training knowledge and to obtain real-time data and perform actual operations. Tool call parameters are usually described using JSON Schema, and the model decides how to fill in parameters based on the Schema—this is also why the clearer the tool's function name, parameter descriptions, and description are written, the more accurately the Agent will call it.

Details of Tool Calling and the Subsequent Learning Path

According to the course demonstration, LangChain's level of encapsulation is very high; parallel calls and multi-step calls are handled automatically. Even when a large number of tools are associated (within about 200), it can still recognize and call them smoothly, and current mainstream large models generally possess this capability. Some detail APIs only need to be understood: invoke is used for batch execution, stream is used for streaming output, and ainvoke and astream with an "A" prefix represent asynchronous execution.

After completing tool integration, the prototype of the Agent is in place. The course's subsequent learning path includes: adding memory so the Agent retains conversations and preferences; handling state management to record task progress; adding middleware to log calls and handle exceptions; and setting up human intervention so that actions requiring confirmation pause first. After building a solid technical foundation, move on to hands-on Agentic RAG and Deep Agents—the former lets the Agent decide when to retrieve based on the task and what additional material is needed, while the latter provides capabilities such as planning, file handling, and sub-Agents. Finally, there is multi-agent collaboration: how to divide work, hand off tasks, and, when something goes wrong, trace the problem along the execution process.

The development approach summarized by the creator is: start from a task, determine what capabilities are needed, and then combine them; for simple tasks, first use a single Agent to complete them, and only gradually add more complex processes and collaboration when needed. What this course aims to help everyone build is exactly this development mindset of combinatory ability, rather than rote memorization of every framework detail.

For those who want to study systematically, the creator says the complete hands-on course is ready and can be obtained by leaving a comment in the comment section.

Agentic RAG is an evolved form of traditional RAG (Retrieval-Augmented Generation). The traditional RAG process is fixed: after the user asks a question, a fixed number of document chunks are retrieved, then inserted into the prompt and handed to the model to generate an answer; whether to retrieve and how many times to retrieve are hard-coded at process design time. Agentic RAG, by contrast, encapsulates retrieval as a tool the Agent can call, and the model autonomously decides whether retrieval is needed, what keywords to search, whether the results are sufficient, and whether supplementary retrieval is needed. This makes it better suited to handling multi-hop questions (such as checking product specifications first and then comparing prices) and scenarios where materials are scattered, but it also brings problems such as uncontrollable retrieval counts and increased latency and cost, usually requiring maximum round limits and fallback strategies.

Deep Agents refers to an enhanced Agent architecture that adds planning, task decomposition, file system operations, and sub-Agent spawning on top of the basic Agent Loop. Its difference from multi-agent collaboration lies in: Deep Agents usually still have a single main Agent controlling the whole situation, and sub-Agents are more like one-off subtask execution units called by the main Agent, returning results to the main Agent after completing the task; multi-agent collaboration, on the other hand, involves multiple Agents with independent roles and goals dividing work, handing off, and negotiating with one another. The former is suitable for long processes that require intermediate artifacts to be persisted (such as writing code or writing reports), while the latter is suitable for complex business scenarios that require multiple perspectives or multiple professional domains to work together.

One-line Summary

Clarifies the relationship between LangChain, LangGraph, and MCP, and lays out an Agent development path from tool integration to multi-agent collaboration.

Paragraph Summary

Based on the hands-on course by Bilibili creator "复返AI," the article clarifies the relationships among several easily confused concepts in Agent development: LangChain provides the common capabilities for building Agents, LangGraph is responsible for orchestrating the task execution flow, and MCP is the unified protocol for connecting to external systems—the three are complementary rather than substitutable. The course then provides a practical path: use UV to set up a Python 3.10+ environment and install LangChain V1 and related model integration packages, with emphasis on mastering the create_agent API that encapsulates the model, tools, and system prompt; then delve into the Agent Loop, the underlying principle of all complex Agents, and demonstrate single-tool calls and parallel multi-tool calls through an intelligent customer service dataset. Finally, it points out subsequent learning directions: memory, state management, middleware, human intervention, as well as Agentic RAG, Deep Agents, and multi-agent collaboration. The core is to cultivate a development mindset of combinatory ability.