LangChain+LangGraph V1.0+Deep Agent: A Beginner's Guide to Agent Development and API Cost Strategy

Why It's Time to Relearn the LangChain Ecosystem

Bilibili creator Xiao Laoshi (Ma Shijie) recently released an introductory course for agent developers, with a clear central message: LangChain and LangGraph have been updated to V1.0, and the official team has also launched a brand-new Deep Agent framework. This update is not a simple patch but a refactoring-level upgrade, adding key capabilities such as middleware.

Xiao Laoshi makes a bold prediction: in the future, 80% of enterprise agents or RAG projects will most likely be built on LangChain, LangGraph, and Deep Agent. He also points out that in today's industrial-grade agent development landscape, he has yet to find a second framework that handles Prompt engineering, middleware, and similar capabilities so thoroughly.

The video shows a screenshot of the LangChain official website, where LangChain, LangGraph, and Deep Agent are presented side by side.

This also explains why the course covers all three frameworks together — they are different layers of the same tech stack, not isolated tools.

The relationship between LangChain, LangGraph, and Deep Agent: LangChain was the earliest popular LLM application orchestration framework, offering foundational components such as Prompt templates, model wrappers, tool calling, memory, and retrieval. It solves the problem of "connecting large models into business code." LangGraph builds on this by introducing a graph-based orchestration paradigm, modeling agent execution flows as nodes and edges. It naturally supports loops, branching, human-in-the-loop, and state persistence, making it better suited for building multi-step, traceable complex Agents. Deep Agent is a higher-level framework introduced by the official team during the V1.0 phase, aimed at "industrial-grade agent" scenarios, with built-in task planning, sub-agent scheduling, middleware, and more. The three are not replacements for one another but a progressive tech stack — from low-level components (LangChain) to process orchestration (LangGraph) to an out-of-the-box agent paradigm (Deep Agent).

The Three-Layer Capability Model for LLM Engineers

Before diving into framework details, Xiao Laoshi proposes a capability tiering standard that every LLM practitioner should benchmark against. He argues that "being able to call DeepSeek^Ad" is far from "knowing large models."

Layer 1: Knowing How to Call

This is the most basic threshold. The creator emphasizes that you must not only master calling a single model but also cover the mainstream large model categories on the market, including:

• General language reasoning models
• Multimodal understanding models
• Text-to-embedding models
• Multimodal embedding models
• Multimodal parsing models (such as DeepSeek OCR)
• Domain-specific large models

He recommends using at least three models from each category in practice.

Layer 2: Knowing Private Deployment and Inference

This layer requires developers to independently handle the deployment and inference of open-source models. According to the creator, he already covered the private deployment of models such as Qwen 3 and DeepSeek R1 in his July-August courses, but plans to split this content into a standalone new course dedicated to deployment and inference frameworks for mainstream domestic and international large models.

The essential difference between private deployment and online API calls: Online calls only require an API Key — model weights, VRAM, and concurrency are all handled by the service provider. Private deployment, on the other hand, means downloading open-source model weights to run locally or on your own servers, requiring you to solve a series of engineering problems on your own: GPU VRAM estimation, quantization precision selection, inference engines (such as vLLM, SGLang, Ollama, llama.cpp), concurrency scheduling, context length limits, and more. The core value of private deployment lies in keeping data within the internal network and controllable cost and customization space, making it especially suitable for finance, healthcare, government, and enterprise scenarios with sensitive data compliance requirements. Correspondingly, its demands on hardware knowledge and operational skills far exceed those of simply calling an API — which is why it is listed separately as the second layer of the capability model.

Layer 3: Knowing Fine-Tuning and Quantization

This is the highest-level requirement and the part missing from most current tutorials.

The basics of fine-tuning and quantization: Fine-tuning refers to continuing to train a pre-trained large model with labeled data from a specific domain, so that the model performs better on vertical tasks. Common approaches include full-parameter fine-tuning and more resource-efficient parameter-efficient methods like LoRA and QLoRA. Quantization, on the other hand, compresses model weights from high-precision formats like FP16 down to INT8, INT4, or even lower, to significantly reduce VRAM usage and inference costs — at the potential cost of some precision loss. In practice, the two are often combined: first fine-tuning on a quantized model using QLoRA, then deploying in quantized format. Mastering this layer means developers are not just "using models" but able to modify them — a skill missing from most introductory tutorials yet essential for industrial deployment.

API Token Purchase Strategy: Covering Mainstream Models for 60 Yuan

For developers who don't plan to do private deployment, the creator offers a very pragmatic suggestion — keep the total budget under 60 yuan. The specific allocation is as follows:

Platform	Suggested Top-up	Purpose
Bailian	~20 yuan	Mainstream domestic open-source models, extremely wide coverage
Zhipu AI	~15 yuan	GLM-4.5/4.6 and search tools
Relay service providers (e.g., Xiao AI)	~16 yuan	Foreign models such as Gemini, GPT-4.5, Claude series
Kimi/Moonshot	~10 yuan	Domestic model supplement

The creator candidly admits that he spent only 70+ yuan on API top-ups throughout all of 2025, including some that was "stolen" by other students. His core attitude is: buy, but don't buy too much.

Course Structure of the Three Frameworks

Xiao Laoshi's course is structured following the official website's organization, covering uniformly:

1. LangChain V1.0 — Basic orchestration and component ecosystem
2. LangGraph V1.0 — Graph-based agent development
3. Deep Agent — An advanced framework for complex industrial-grade agents

He specifically mentions the middleware capabilities and Deep Agent module added in V1.0, considering these the "most important, most important" parts of future agent development.

Note that this video is essentially the course's opening "declaration and preparation." The private deployment portion is intentionally deferred to a separate new course. For developers who want to follow this learning path, understanding the overall framework is more important than rushing to write code.

The role of middleware in agent development: In the context of LangChain V1.0, middleware refers to reusable processing modules inserted into the agent's execution flow, used to uniformly handle cross-cutting concerns before and after model calls — such as context compression, tool-calling permission verification, logging and observability instrumentation, sensitive information filtering, failure retries, and human review interception. Its value lies in extracting these common logic patterns out of business code, keeping the agent's main flow concise while ensuring the stability and compliance required for industrial-grade scenarios. This is also why the creator considers middleware and the Deep Agent module the "most important, most important" parts — they determine whether an agent can move from demo to production environment.

One-line Summary

LangChain ecosystem V1.0 refactoring upgrade, plus a three-layer capability model for LLM engineers and a 60-yuan API budget plan.

Paragraph Summary

This article presents the core viewpoints from Bilibili creator Xiao Laoshi's introductory course for agent developers: LangChain and LangGraph have been upgraded to V1.0, with a new Deep Agent framework added, viewed as a refactoring-level upgrade with key new capabilities like middleware. The creator predicts that 80% of future enterprise agents or RAG projects will be built on this tech stack. The article also proposes a three-layer capability model for LLM engineers — knowing how to call, knowing private deployment and inference, and knowing fine-tuning and quantization — and offers practical advice on API Token purchases: keep the total budget under 60 yuan, covering mainstream domestic and international models through four channels: Bailian, Zhipu AI, relay providers, and Kimi. The course structure follows the official website organization, uniformly covering LangChain V1.0, LangGraph V1.0, and Deep Agent, with private deployment content to become a standalone course.