LangChain V1.3 Hands-On Tutorial: A Complete Breakdown of RAG, Multi-Agents, and Engineering Mindset

Why Learn LangChain Instead of Chasing After Tools?

In the field of AI application development, many beginners fall into a deeply rooted misconception: they believe that once they've mastered tools like Cursor, Claude Code, or Codex, they're all set. In the opening of his LangChain V1.3 tutorial, Bilibili content creator Turing Loulan poses a thought-provoking question—if your entire workflow depends on a single tool, and you're helpless the moment you switch tools, are you playing the tool, or is the tool playing you?

This question strikes at the core anxiety of the AI era. Tools are indeed the most direct vehicle for putting applications into practice, but new tools keep emerging endlessly: Cursor got hot, then Claude Code got hot, and after Claude Code came CodeX. Endlessly chasing tools only traps you in a vicious cycle of learning fatigue. What you should really focus on is how you personally use large models to solve real work problems—that's where the core value lies.

An even more practical concern is that these tools aren't equally accessible to everyone. Take Claude Code as an example: its restrictions on access from within China and its data-collection controls are continually tightening. When your workflow is completely bound to a restricted tool, you lose your autonomy.

The Fundamental Dilemma of Describing Requirements and Context Engineering

Everyone's now "programming with their mouth," but the hardest part is precisely how to articulate requirements clearly. The creator gives a highly persuasive example: Can you get a large model to replicate the Spring framework? In theory, the model has seen all of Spring's code and understands it more deeply than any individual could. But when you actually try, you'll find—you simply don't know how to describe the requirements. Spring's internal features and logic are all intertwined; how do you express that clearly in natural language?

Real business scenarios are often even trickier. E-commerce systems may seem cliché, but the business "twists and turns" behind each enterprise are impossible to grasp without a seasoned project manager—let alone describe precisely in natural language.

To tackle this challenge, the industry has developed context-engineering solutions like RAG (Retrieval-Augmented Generation). RAG was first formally introduced by Meta AI's research team in 2020. Its core idea is to combine the model's parametric knowledge with real-time retrieval from external knowledge bases: after a user asks a question, the system first vectorizes the question and retrieves relevant document snippets from the knowledge base, then injects these snippets along with the original question into the prompt, letting the model "answer with an open book." This architecture effectively addresses three major pain points of large models: knowledge cutoff dates, hallucination, and the inability to access private data. Context engineering further extends this concept, emphasizing the fine-grained design of the context injected into the model—including document chunking strategies, choice of vectorization methods, retrieval ranking algorithms, and other engineering details. There are also complementary methodologies such as SDD (Spec-Driven Development).

But there's a critical blind spot that's often overlooked: large models are black boxes to everyone—no one can truly see their internal reasoning process. Cases that claim "RAG system accuracy improved from 60% to 90%" rely on scoring criteria that are themselves hard to measure objectively. Natural language isn't like numbers; the same question can be phrased in countless ways, and effectiveness ultimately has to be validated through practice.

The Engineering Mindset: Precise Control Over Tokens

Since a model's effectiveness can only be validated through practice, the cost of practice becomes an unavoidable issue. Directly using tools like Claude Code or CodeX consumes tokens at a considerable expense—the good ones basically all require payment. Tokens are the basic billing unit for large model APIs, roughly equal to 0.75 English words or 0.5 Chinese characters. Take GPT-4o for example: input costs about $2.5 per million tokens and output about $10 per million tokens, and a single run of a complex multi-step task can consume hundreds of thousands of tokens. When you just want to verify whether an idea is feasible, and halfway through you realize you're going in the wrong direction and want to stop—the money has already been spent.

This is precisely where the value of the AI engineering mindset that the creator repeatedly emphasizes comes in. Take the way a complex Agent works as an example: faced with a complex problem, an Agent doesn't answer directly, but first plans—breaking down the task and dispatching different Agents to handle parts separately (some responsible for searching online, others for data integration), and finally consolidating everything into a report.

Suppose something goes wrong mid-execution—for instance, the wrong keyword was used during a web search. Someone lacking an engineering mindset can only rerun everything from scratch, wasting all the tokens consumed by the previous steps. But LangChain provides a feature called Time Travel: it retains the historical results that were correctly completed, and re-executes only from the step where the problem occurred.

This mindset also extends to the Human-in-the-loop (HITL) mechanism. HITL is a classic concept in automated control, and when introduced into AI Agent systems, it specifically refers to setting up human intervention checkpoints during an Agent's autonomous execution: simple problems that don't require calling a large model can be rejected directly; high-risk operations (such as sending emails, executing code, or writing to a database) require human confirmation; and when a task has been sufficiently completed, it can be terminated early to avoid ineffective calls. This fine-grained approach to token management also explains why big tech companies like Microsoft, Google, and Amazon have shifted from "pushing AI on everyone" to "limiting tokens" and implementing internal Token Budget policies—unrestrained token burning puts even tech giants under pressure. Only by mastering the thinking behind the tools can you become the master of AI, rather than being led around by the nose.

Why LangChain Is the Best Starting Point for Learning Agent Development

LangChain is essentially a low-level programming framework for building Agents. Upper-layer products like Cursor and Claude Code all rely on this kind of framework for support. Compared with frameworks like Spring AI and LlamaIndex, LangChain has two core advantages:

The Deepest Accumulation: A Seasoned Veteran

LangChain is one of the earliest Agent frameworks—it existed before the concept of an Agent had even taken shape. Just as you'd seek out an experienced, well-traveled expert when you need help, this kind of "veteran framework" has accumulated more solid, battle-tested experience.

The Most Active Ecosystem: Quickly Adopting New Standards

LangChain's ecosystem iterates extremely fast. Whether it's MCP or the Skill mechanism, it keeps up in a timely manner. MCP (Model Context Protocol) is an open protocol released by Anthropic in November 2024 alongside Claude, aimed at solving the problem of inconsistent standards for connecting AI models with external tools and data sources—much like the emergence of the USB interface, which eliminated the need to customize a connection method for each device. MCP defines a standardized Client-Server communication specification: the AI model acts as the Client, while various tools and data sources act as Servers, and the two sides perform handshakes, capability declarations, and request-response exchanges through a unified protocol. Currently, mainstream frameworks including LangChain, Cursor, and Continue all support MCP, marking that the Agent tool ecosystem is moving toward standardization. The new version also introduces the DeepAgent framework, which supports a Skill usage approach similar to other mainstream tools.

The three modules in LangChain V1.3—LangGraph, Chain, and DeepAgent—represent three different approaches to building Agents:

• LangGraph: Built on a directed graph structure, it borrows from the computer science concepts of the state machine and the directed acyclic graph (DAG), modeling the Agent's execution flow as a combination of nodes and edges. It supports conditional branching, loops, and parallel collaboration among multiple Agents. Its shared-state mechanism makes it especially well suited for complex scenarios requiring multi-step planning and self-correction, and it is currently the most widely used approach;
• Chain: Built on a chained structure, its logic is relatively simple, making it suitable for beginners;
• DeepAgent: Emphasizes autonomous planning capability—easy to get started with but harder to master in depth.

Once you've thoroughly mastered LangChain, picking up Spring AI or LlamaIndex will be far easier—this is precisely the long-term value of a classic framework.

The Three Core Principles of the Course Design

This V1.3 course has undergone a systematic upgrade based on absorbing extensive student feedback, reflected primarily in three "emphasize this, not that" principles:

First, emphasize the system, not the features. Previous courses either covered only LangChain or only LangGraph, rarely integrating the two. This time, they are redesigned as a complete system: the first module covers the fundamentals of Agents (how to interact with large models, tool-calling mechanisms, MCP integration, etc.)—these are the general capabilities you must master regardless of which construction approach you use—followed by a progressive sequence of LangGraph → Chain → DeepAgent.

Second, emphasize hands-on practice, not theory. From the very first chapter, you dive straight into code, letting students "learn by doing"—first experiencing a tool's actual effects, then going back to break down the underlying principles. Practice has proven this approach far more effective than the learning path of covering lengthy theory first and then getting hands-on.

Third, emphasize the ideas, not the code. The parameter details of each API are endless, and rote memorization is pointless. What matters is understanding the underlying ideas behind building Agents—what a Graph is, what problems a Chain solves, how autonomous planning works. Large models can generate the specific code, but how to combine tools, how to design application architecture, and how to accurately describe requirements—these thinking skills are the true core competitiveness.

Thoughtful Arrangements for Students of Different Backgrounds

The course includes targeted supplements addressing common student concerns:

• Limited understanding of large models: LangChain is itself a tool for working with large models. The framework has already filtered out the parts that are genuinely useful in practice, so just follow along;
• Weak Python foundation: Python has an extremely low barrier to entry, and each code example is small in scope—type them out a few times and you'll naturally get familiar with them;
• No high-end GPU: The course includes plenty of localized content, walking you step by step through deploying large model services locally, while also accounting for enterprise data security scenarios;
• Lack of application development experience: You'll build a multi-agent project from scratch, gradually developing your development skills, and integrate LangSmith for API call monitoring and debugging. LangSmith is the official observability platform for LLM applications released by LangChain. It provides complete trace tracking (visualizing the inputs, outputs, latency, and token consumption of each LLM call), evaluation (quantitatively measuring an application's accuracy by building test datasets), and multi-model Playground comparison experiments. For multi-agent systems, it can reconstruct the complete Agent execution chain and pinpoint exactly which call at which node caused the deviation in the final result—making it an indispensable debugging tool for engineering implementation.

Conclusion: Become a True Driver in the AI Era

"AI is the future, You must be the driver."—this is the message the creator offers to every learner. AI is undoubtedly the future, but the real dividing line isn't how many tools you can use—it's the depth of your understanding of large model engineering.

Some people can do the work of an entire team on their own with the help of large models, while others still worry about being replaced by AI—the gap lies in the depth and breadth of one's engineering mindset. Only by mastering the core ideas behind frameworks like LangChain can you truly command the AI era, rather than being swept along by the tide of tools.

Key Takeaways