LangChain 1.3 Systematic Tutorial: Hands-On RAG/Agent/MCP/LangGraph in Practice

AI tools keep emerging—just as you finish learning one, a new one appears—and many people get stuck in an exhausting cycle of "chasing tools." In his newly released LangChain 1.3 systematic tutorial, Bilibili creator Loulan makes a sharp point: rather than being led around by tools, master the underlying framework and become the one in control of the tools. This course runs from architecture fundamentals to hands-on RAG, Agent, MCP, and LangGraph multi-agent projects, aiming to help learners build a transferable system for AI application development.

Why learn an underlying framework instead of chasing tools?

At the start of the course, Loulan points directly at a common dilemma among today's AI learners: tools like Cursor, Windsurf, Claude Code, and CodeX iterate extremely fast—following along is tiring, and even after finishing you may not be able to build your own application. More importantly, these tools embed the developer's design philosophy; once your needs diverge from the tool's assumptions, you can end up in a passive position where "you can't build a project without the tool."

Using Claude Code as an example, he points out that the tool has layered increasingly strict security measures for users in China—from discontinuing service and banning accounts to capturing IP time zones and even tagging China-controlled enterprises. If every project depends on a single product to be completed, then once the product strategy changes, developers have no recourse. Learning an underlying framework like LangChain means you can reference or even customize similar functionality to solve concrete problems around you—for most people, you don't need to build a tool for everyone; solving your own problems is enough.

The course also addresses the misconception of "programming by talking": stating requirements seems simple, but the requirements of complex business scenarios are extremely hard to describe clearly. It's like asking a large model to replicate a Spring framework—it has studied the source code, but the complexity of business scenarios often exceeds that of open-source frameworks. The truly scarce ability isn't writing prompts; it's the practical ability to break down requirements, validate them, and iterate.

LangChain is an open-source framework for building large language model (LLM) applications, providing modular components (such as model interfaces, prompt templates, memory, tool calling, etc.) that help developers integrate LLM capabilities into complex applications. Its core value lies in the abstraction layer: developers don't need to directly handle API differences between model providers, and can switch models through a unified interface; at the same time, the framework includes built-in implementations of common patterns such as chained calls, agents, and retrieval-augmented generation (RAG). LangGraph is a library in the LangChain ecosystem focused on stateful, multi-step workflow orchestration. It models applications as graph structures, where nodes represent computation steps and edges define control flow, making it suitable for building agent systems that require loops, conditional branches, and persistent state. Deep Agents is a higher-level wrapper that comes with built-in capabilities such as planning and tool use, simplifying the construction of complex agents. The combination of these components enables developers to define application logic declaratively rather than implementing low-level interactions from scratch.

The core design philosophy of the LangChain 1.3 course

This course is an upgraded version of Loulan's LangChain 0.3 course, with targeted adjustments made after incorporating student feedback. The course design follows three principles: emphasize systems over features, emphasize practice over theory, and emphasize thinking over code.

The most notable change is teaching LangChain and LangGraph together. In the past, the two were often treated as separate courses because the approaches to building agents differ considerably, but Loulan believes they belong to the same broader LangChain framework and share common underlying parts. The course extracts the "Agent foundation"—the basic capabilities that encapsulate interaction with large models—as a shared base, and on that basis expands into different construction approaches such as LangChain Chain, LangGraph, and DeepAgent, avoiding redundant learning.

Another focus is the actual positioning of LangChain in enterprises. Loulan admits that enterprises use LangGraph more and Chain relatively less, because Graph is more flexible. But the course still retains Chain content as a supplement to thinking—"If you don't understand how a database interoperates with other technologies and what position it occupies in an overall architecture, it's impossible to learn this deeply."

RAG (retrieval-augmented generation) is a technical paradigm that combines retrieval from external knowledge bases with large-model generation. Its process typically includes: splitting documents and vectorizing them into a vector database; when a user asks a question, retrieving relevant snippets from the database; and injecting the retrieval results as context into the prompt to guide the large model to generate fact-based answers. RAG can effectively alleviate hallucinations and outdated knowledge in large models, and does not require fine-tuning the model. An Agent refers to a system with autonomous decision-making capabilities that can understand goals, decompose tasks, call tools (such as search, computation, APIs), and iteratively execute based on environmental feedback. Agents in LangChain usually consist of a model, a tool set, and a decision loop, while LangGraph provides more fine-grained control flow and state management through graph structures, making it suitable for complex multi-agent collaboration scenarios.

How hands-on projects run through the course

The course emphasizes "run code first." After introducing what LangChain is, it immediately guides learners to connect to various large models, and only goes deeper after getting things running. Loulan's explanation is straightforward: "One piece of code is worth a thousand words—play with it and you'll know whether it's good."

The multi-agent project practice is the centerpiece of the course. The notes provide only a flowchart; the rest of the code is handwritten line by line from scratch, covering the entire process of design, decomposition, and implementation. RAG applications and agent construction are likewise practice-driven, allowing learners without a Python background or application development experience to accumulate experience by following along with projects.

The course also adds a module on building large-model services locally. Some enterprises are unwilling to call cloud APIs due to data security concerns, making local deployment a hard requirement; for individual learners, local calls can also save token costs. The course covers building a local model system and practical techniques such as using New API as a relay station.

Token consumption and time travel: an overlooked cost awareness

Loulan spends considerable time in the course on token planning. He mentions that major companies such as Microsoft, Amazon, and Google are shifting from "AI everywhere" to limiting token consumption, because using large models without discipline turns costs into a bottomless pit. Ordinary users need to plan tokens the way they plan system architecture.

He uses the task decomposition mechanism of mainstream agent products as an example: complex tasks are first broken into subtasks and then executed in sequence. But the problem is that if the first few steps succeed and a middle step fails due to network fluctuations, many products choose to rerun the entire process, and money flows out like water. The "time travel" tool provided by LangChain can save the task execution process and continue from the failed step, so completed steps don't need to be paid for again. This tool isn't cutting-edge, but it's professional—only by using it well can you make every dollar count.

A token is the basic unit of text processed by a large model, roughly a word or a fragment of characters. Model calls are billed by the number of input and output tokens, and the unit prices for input and output often differ. Complex tasks (such as long document analysis or multi-round agent execution) consume large numbers of tokens, and if the process is poorly designed (such as repeatedly processing the same content or fully retrying after a failure), costs can rise sharply. Therefore, token planning involves prompt engineering optimization (streamlining context), caching mechanisms (avoiding repeated computation), and fault-tolerant design of execution flows. Time travel is a debugging and fault-tolerance feature provided by LangGraph. It persists the state of each step in a workflow through a checkpoint mechanism. When a node fails, execution can resume from the most recent checkpoint rather than rerunning the entire process, thereby saving token consumption and execution time. This feature also makes it easy for developers to replay and debug the behavior of complex agents.

Ecosystem activity and language migration

Another reason Loulan recommends LangChain is its active ecosystem. Standards such as MCP and Skill were initially proposed by certain products, and LangChain quickly provided direct support—for example, the Deep Agents module can directly load Skills, and after downloading, a single API is all it takes. This means that when new standards appear, LangChain users can integrate them quickly without worrying about low-level protocol details.

Regarding the common confusion about "what language to use for agent development," Loulan's answer is: once you understand the LangChain system well, language is not a barrier. LangChain has Python and TypeScript versions, and the Java ecosystem has LangChain4j, LangGraph4j, and Spring AI Graph. The ideas are interconnected, and migration costs are low.

At the end of the course, Loulan also candidly lays out the boundaries of applicability: for learners who are unfamiliar with Python, lack a foundation in application development, or can't afford expensive GPUs, the course provides paths for following along with projects and local deployment; but if there are deeper customization needs, separate communication is required. His core claim remains consistent—in the AI era, there will be more and more tools, and only by mastering underlying frameworks and developer thinking can you become the person who drives the tools rather than the one driven by them.

MCP (Model Context Protocol) is an open protocol designed to standardize how large models connect to external tools and data sources, enabling different models and tools to interoperate. Skill refers to reusable capability modules, typically encapsulating the calling logic for specific tasks (such as search or file operations), for agents to load dynamically. The LangChain ecosystem's rapid adaptation to such new standards lowers integration costs for developers—when new tools or protocols appear in the community, it often takes only a call to the interface provided by the framework, without delving into low-level implementation. In addition, LangChain's multilingual implementations (Python, TypeScript, Java, etc.) maintain consistency in the conceptual model—for example, abstractions such as Chain, Agent, and Tool have the same meaning across different languages. Therefore, after mastering one language, migrating to another mainly involves syntax and API differences rather than relearning design philosophy.

One-line Summary

Bilibili creator Loulan argues for learning the LangChain underlying framework rather than chasing AI tools, to avoid product lock-in and take control of development.

Paragraph Summary

The article introduces Bilibili creator Loulan's LangChain 1.3 systematic tutorial, whose core idea is that learners should master the underlying framework rather than chase rapidly iterating AI tools, in order to avoid being locked into a single product. The course teaches LangChain and LangGraph together, extracts the Agent foundation to reduce redundant learning, and is practice-driven, covering RAG, agents, multi-agent projects, and local deployment. The article also emphasizes the importance of token cost planning, as well as the LangChain ecosystem's rapid response to new standards such as MCP and Skill and the convenience of language migration. Overall, it aims to help learners build a transferable system for AI application development.