LangChain 1.3 Practical Guide: Framework Thinking and Core Essentials of Agent Development

In an era where AI tools emerge endlessly, many developers find themselves trapped in a cycle: constantly chasing new tools without ever building core competencies. Bilibili content creator Loulan proposed a thought-provoking perspective in his LangChain 1.3 course — rather than chasing high-level products, master the underlying frameworks. This article distills the core value of LangChain 1.3 and the developmental mindset shift behind it, based on this course content.

Why Learn Underlying Frameworks Instead of High-Level Tools

From early tools like Cursor to later ones like Claude Code and Codex, AI programming tools are iterating at an astonishing pace. Many people equate "learning AI" with "learning tools," believing that whichever tool is closest to the application offers the best learning ROI. But this approach has obvious limitations.

In software engineering, the relationship between "underlying frameworks" and "high-level tools" is similar to that between operating systems and applications. A Framework provides a set of reusable infrastructure and design patterns upon which developers build specific applications; a Tool is a pre-packaged product where users can only operate within its preset functionality. In the AI programming space, products like Cursor and Claude Code are essentially built on top of framework capabilities from LangChain, LlamaIndex, and others, layered with specific UI design, workflow orchestration, and product logic. Once you understand the core mechanisms at the framework level — prompt orchestration, tool invocation, memory management — even if a particular product shuts down or restricts usage, you can quickly build alternative solutions based on the same underlying capabilities.

Loulan states bluntly in the course: all high-level tools carry their developers' own assumptions. When your needs don't align with the tool designer's thinking, or when the tool becomes unavailable for various reasons, you're left in a passive position. He specifically cites Claude Code as an example — due to escalating security restrictions on Chinese users (including capturing IP addresses, time zones, and other information to flag accounts), many domestic developers face the predicament of being unable to use it normally. If your entire project depends on a specific product to function, then "are you playing the tool, or is the tool playing you" becomes a very real question.

This is precisely the value of learning underlying frameworks like LangChain. These popular products are essentially built on top of underlying frameworks. Once you understand the framework's underlying logic, even if you can't directly modify closed-source products, you can do customized development based on the same features to solve real problems around you. For most people, what we truly need isn't a universal tool for everyone, but the ability to solve our own specific problems.

Two Major Cognitive Misconceptions in AI Programming

The course reveals two cognitive misconceptions prevalent among AI developers today — this section is particularly thought-provoking.

Misconception 1: More Complete Prompts Always Yield Better Results

Many short videos claim that optimizing prompts or context engineering can boost RAG accuracy from 60% to 90%. Loulan challenges this: all our interactions with large models are based on natural language, so how exactly do you score the effectiveness of natural language descriptions? There must be rigorous verification methods behind this — it's not as simple as making verbal claims.

Some technical background is necessary here. Context Engineering is a concept that emerged in 2024-2025, referring to the systematic design and management of all contextual information fed to large language models, including system prompts, user conversation history, retrieved external knowledge, tool call results, and more. It's broader in scope than pure Prompt Engineering, emphasizing the architectural design of the entire information flow. RAG (Retrieval-Augmented Generation) is a typical context engineering practice — first retrieving relevant document fragments from a knowledge base, then injecting them as context into the model to improve answer accuracy and timeliness. But as noted, the actual effectiveness of such optimizations needs to be quantitatively verified through rigorous evaluation systems (such as human annotation comparisons, automated evaluation metrics, etc.).

More critically, imagine the large model as a human you're communicating with — even between people, clearly stating requirements doesn't guarantee the other person fully understands, and miscommunications happen all the time. Why would you believe a large model will definitely understand your complete prompt? Therefore, good prompts must go through training, validation, and iteration, all of which depend on the ability to practice quickly: have an idea, quickly build a small demo to validate it. Without practice, all prompts are empty talk, and the tokens spent are wasted.

Misconception 2: Neglecting Token Cost Planning

As large model usage deepens, many people find costs rising while outputs become increasingly hard to measure. This isn't just an individual dilemma — even major companies like Microsoft, Amazon, and Google have shifted from "AI for everyone" to "token limits."

To understand the severity of this issue, you need to grasp the basics of Token Economics. A token is the basic unit of text processing for large language models — in English, each word corresponds to roughly 1-1.5 tokens, while each Chinese character typically corresponds to 1.5-2 tokens. Model pricing usually charges separately for input and output tokens; for example, GPT-4o is priced at approximately $2.5/million input tokens and $10/million output tokens. In Agent scenarios, due to multi-turn reasoning, tool calls, and task decomposition, token consumption for a single task can be tens of times that of a normal conversation. A complex multi-step Agent task might consume tens or even hundreds of thousands of tokens. This is why major companies have begun implementing quota management for internal AI usage — unconstrained token consumption leads to cost overruns, while output doesn't grow linearly.

Loulan's solution is: plan token usage the way you plan system architecture. He uses the task planning capabilities of mainstream Agent products as an example — complex tasks are broken into multiple sub-steps, completed sequentially by different Agents. The problem is, if an intermediate step fails (say, network fluctuation causes a web search to fail), the traditional approach either throws an error or reruns the entire task from scratch, burning through tokens like water.

LangChain provides a professional tool for this — time travel, which saves the entire execution process of a task. When a problem is detected at a certain step, you can choose to rerun from the failed step without recomputing previously successful steps.

From a technical implementation perspective, the time travel feature in LangGraph is essentially a state management mechanism based on Checkpoints. When an Agent executes multi-step tasks, the framework automatically saves the complete execution state at each critical node (including completed reasoning results, intermediate variables, tool call return values, etc.). When a subsequent step fails, developers can roll back to any historical checkpoint, modify inputs or adjust strategies, and re-execute without starting from scratch. This shares the same philosophy as transaction rollback in databases and version revert in Git, but when applied to AI Agent scenarios, it directly delivers significant token cost savings and dramatically improved debugging efficiency. Mastering such tools is how you truly put your money where it matters, ensuring every token is spent on the core of problem-solving.

LangChain's Unique Advantages and Course Design Philosophy

Among the many Agent development frameworks (such as LlamaIndex, Spring AI, etc.), why specifically recommend LangChain? Loulan offers two core reasons.

Most Experienced and Most Active Ecosystem

First, LangChain is one of the earliest Agent development frameworks, having accumulated the most problems and experience — like seeking help from someone with extensive experience, it's more reliable. Second, its ecosystem is extremely active. Standards like MCP and Skill, initially proposed by products like Claude Code, receive rapid direct support from LangChain.

Here it's worth explaining these emerging standards. MCP (Model Context Protocol) is an open standard launched by Anthropic in late 2024, designed to provide large language models with a unified way to connect to external tools and data sources. It defines standardized interfaces for how models discover, invoke, and receive external resources — similar to how the USB protocol provides a unified connection standard for various peripherals. Skill is a reusable Agent capability unit packaging standard that allows developers to bundle specific domain tool call chains, prompt templates, and processing logic into distributable "skill packs." LangChain's rapid integration of these emerging standards demonstrates its agility and inclusiveness as a core ecosystem framework.

Taking Skill as an example, it's already directly integrated in the Deep Agents module — download an API and you're ready to use it, with developers not needing to worry about the underlying protocol implementation at all.

More importantly, LangChain sits at the "eye of the storm" in the entire Agent framework ecosystem. Built on Python and TypeScript, once you truly master it, language and framework migration barriers disappear — want to switch to Java? There's Spring AI and LangChain4j. Want graph structures? There's LangGraph4j and Spring AI Graph. The underlying philosophies of these frameworks are interconnected; mastering LangChain is equivalent to unlocking the pathways to numerous surrounding frameworks.

Three Course Design Principles

This course follows three clear design principles: emphasize systems over features, practice over theory, thinking over code.

Interestingly, this course integrates LangChain and LangGraph into a unified whole. Previously, they were often taught as separate courses because their approaches to building Agents differ significantly. But fundamentally, both are different modules under the larger LangChain framework, sharing common underlying capabilities for wrapping large model interactions. The course extracts this common foundation and calls it the "underlying base of Agents," allowing the higher-level construction approaches to naturally connect.

Decoding the Relationship Between LangChain, LangGraph, and Deep Agent

Understanding the relationship between these three is key to mastering the LangChain ecosystem.

• LangChain (Chain Mode): This is the most classic Agent construction philosophy, where programmers pre-define process branches — determining how to handle incoming problems. The Chain mode originates from LangChain's initial design philosophy — chaining multiple processing steps into a pipeline where data flows through each node in a fixed order. This mode suits scenarios with determined flows and simple branching, requiring developers to pre-define all possible execution paths. It's used relatively less in enterprises currently, but still has value as a supplementary approach.

• LangGraph (Graph Mode): More flexible than Chain — essentially everything LangChain can do, LangGraph can do as well, and more elegantly, making it more widely adopted in enterprise applications. Graph mode models the Agent's execution flow as a Directed Graph, where nodes represent processing steps and edges represent state transition conditions. Graph mode supports complex topological structures including loops, conditional branches, and parallel execution, with built-in state persistence capabilities that allow Agents to pause, resume, and backtrack. This flexibility makes it better suited for building enterprise-grade complex Agents.

• Deep Agent: Built on LangGraph at the underlying level, classified as an "Autonomous Agent." Its biggest difference from the other two is that task planning is entirely handled by the large model itself — the model autonomously plans tasks and executes them. Autonomous Agents represent the cutting edge of current AI Agent development, with a core loop typically being: observe environment → think about next step → execute action → evaluate results → decide whether to continue. The advantage of this mode is handling open-ended, non-predefined complex tasks, but it also introduces challenges in controllability, predictability, and cost management. Deep Agent being built on LangGraph means it inherits graph mode's state management and checkpoint capabilities while implementing an autonomous decision-making logic layer on top.

Loulan emphasizes that while you might specialize in only one approach in actual work (for example, LangGraph alone is usually sufficient), exposure to more construction philosophies builds a stronger foundation. It's like studying databases — if you know nothing about other technologies, you can't understand how databases fit within the overall architecture, making it difficult to go deep.

Hands-On from Scratch: Building a Complete AI Application System

The course's biggest feature is its abundance of practical cases rather than armchair theorizing. One highlight is "building a medical multi-agent project from scratch" — starting from design, with just a flowchart, coding line by line. While this approach requires some Python foundation and application development capability, it's precisely through hands-on practice that concerns like "not familiar with Python" or "no application development background" can truly be resolved.

Multi-Agent architecture is one of the mainstream paradigms in current Agent development, distributing complex tasks among multiple specialized Agents working collaboratively. In a medical scenario, for example, this might involve a "Symptom Analysis Agent," "Medical Knowledge Retrieval Agent," "Diagnosis Suggestion Agent," and "Medication Recommendation Agent" — each Agent focusing on its own capability domain, collaborating through message passing and state sharing to complete the overall task. The core challenges in this architectural design include inter-Agent communication protocol design, task allocation strategies, and error handling mechanisms.

Additionally, the course supplements content on local large model deployment. For enterprise users who don't want to consume tokens calling remote services, or who need private deployment for data security reasons, local invocation is essential — after all, entrusting private information to third-party cloud services always carries risk. Local deployment typically uses inference frameworks like Ollama, vLLM, or llama.cpp to deploy open-source large models (such as Llama, Qwen, DeepSeek, etc.) on local GPU servers, providing services through interfaces compatible with the OpenAI API format. This ensures data sovereignty and security while still leveraging large model inference capabilities. The course also covers practical techniques like setting up relay stations with new APIs, helping developers flexibly switch between local and cloud models.

Conclusion: Technical Barriers Are Lowering but Conceptual Barriers Remain

Loulan repeatedly emphasizes one core point throughout the course: the technical barrier to development is now very low, but the conceptual barrier still exists. Using the same large models, some people achieve excellent results while others see minimal returns — the gap lies in mindset.

He suggests that every large model user, even those who don't plan to become developers, should cultivate "developer thinking" — learning to think from a developer's perspective to use large models more effectively. The core of this "developer mindset" includes: understanding how systems are layered, how data flows, how errors are handled, and how resources are optimized. Once you possess these mental models, whether you're writing prompts, designing Agent workflows, or evaluating AI products' capability boundaries, you'll be far more precise and efficient than operating from a pure "user perspective."

In this AI era full of change, only by mastering underlying frameworks and core thinking can we become the masters of our own technical growth.