LangChain 学习路线 · 前端工程师的 8 周计划

作者:富朝阳日期:2026/11/16

LangChain 学习路线 · 前端工程师的 8 周计划

前端工程师 · 8 周 · Python

从组件树到检索链

给前端工程师的 8 周 Python LangChain 实战路线。不堆概念,按周推进;每个知识点配可运行案例,RAG 从加载到生成逐环节拆解,最后接上你最熟的那一层:前端。

8 周 · 7 个 RAG 环节 · Python 3.11 · LangChain 1.x · 约 45 分钟读完

RAG 全链路示意

阶段流程
离线索引1 文档加载 → 2 切分 → 3 向量化 → 4 入库
在线查询5 检索 → 6 重排 → 7 生成 + 引用

01 8 周路线图

每天 1~1.5 小时:30 分钟读文档,60 分钟写代码,15 分钟记笔记。不要只看不写——每周都必须留下一个能跑的东西。

周主题产出
0Python 速成(前端视角)能写异步脚本、装 venv、读写 pydantic 模型
1LLM 调用 + Prompt + LCEL命令行聊天 + 流式输出
2结构化输出、工具调用、消息历史会「调函数」的助手
3RAG 上半场:加载 → 切分 → 向量化 → 入库本地知识库可检索
4RAG 下半场:检索 → 重排 → 生成 → 引用带出处的问答 demo
5高级检索:混合检索、多查询、ParentDoc、HyDE检索命中率明显提升
6评估 + LangSmith + FastAPI 上线有指标的 API 服务
7LangGraph + Agent(含 Agentic RAG)自适应 RAG 图
8结课项目 + 前端联调可演示作品

先建立心智模型

LangChain 里的大部分概念,都能在浏览器里找到对应物。先映射,再学 API,速度会快很多。

LangChain前端对应物
ChatPromptTemplate模板字符串 / JSX props
LCEL a | bRxJS pipe() / Promise 链 / Unix 管道
RunnableParallelPromise.all
chain.stream()SSE / ReadableStream
Document带 metadata 的对象
VectorStore / RetrieverAlgolia / ES 索引,封装好的 search()
LangGraph / checkpointer状态机 + Redux reducer / 本地存档
LangSmithSentry + Chrome DevTools
FastAPI / LangServeBFF 层

版本提醒

网上大量教程是 0.0.x / 0.1,API 差异很大。1.x 里经典链(create_retrieval_chain 等)迁到了 langchain-classic,新项目推荐 LCEL 手动组装 或 LangGraph。下文的 RAG 主代码用手动 LCEL,版本兼容性最好。


02 Python 速成 · 第 0 周 · 3~5 天

只学用得到的:环境、类型、异步、文件与 JSON。会 TypeScript 的话,这一周主要是换语法。

环境

1python -m venv .venv
2.venv\Scripts\activate
3pip install -U langchain langchain-openai langchain-community `
4  langchain-text-splitters langchain-chroma python-dotenv
5

requirements.txt 一定要锁版本,LangChain 迭代很快:

1langchain==1.*
2langchain-openai==1.*
3

类型 + pydantic(对应 TS interface + zod)

1from pydantic import BaseModel, Field
2
3class Query(BaseModel):
4    text: str
5    top_k: int = Field(default=4, ge=1, le=20)  # zod 的 min/max
6
7q = Query(text="年假怎么算", top_k=3)
8print(q.model_dump())   # {'text': '年假怎么算', 'top_k': 3}
9

异步(对应 async/await + Promise.all)

1import asyncio
2
3async def fetch(i: int) -> str:
4    await asyncio.sleep(0.5)
5    return f"result-{i}"
6
7async def main():
8    results = await asyncio.gather(*(fetch(i) for i in range(5)))
9    print(results)
10
11asyncio.run(main())
12

必须掌握

list / dict 推导式、生成器 yield、f-string、try/except、with、*args / **kwargs、json、pathlib、从 .env 读取配置。


03 LangChain 核心抽象 · 第 1–2 周

这一章的目标不是背 API,而是理解一条数据怎么从字符串流进模型、再流回前端。

最小心智模型

1from dotenv import load_dotenv
2from langchain_openai import ChatOpenAI
3from langchain_core.prompts import ChatPromptTemplate
4from langchain_core.output_parsers import StrOutputParser
5
6load_dotenv()
7
8llm = ChatOpenAI(
9    model="gpt-4o-mini",
10    temperature=0,
11    # 国内模型走 OpenAI 兼容协议,改 base_url 即可:
12    # base_url="https://api.deepseek.com/v1", model="deepseek-chat"
13)
14
15prompt = ChatPromptTemplate.from_messages([
16    ("system", "你是{role},回答简洁。"),
17    ("human", "{question}"),
18])
19
20chain = prompt | llm | StrOutputParser()   # 这就是 LCEL
21print(chain.invoke({"role": "老师", "question": "什么是向量数据库?"}))
22

要点:invoke 传 dict → 模板填充 → 模型 → 解析。| 左边输出自动成为右边输入。

流式(前端最熟)

1for chunk in chain.stream({"role": "老师", "question": "讲个冷笑话"}):
2    print(chunk, end="", flush=True)
3

并行 + 透传

1from langchain_core.runnables import RunnableParallel, RunnablePassthrough
2
3chain = RunnableParallel(
4    original=RunnablePassthrough(),        # 原样保留输入
5    upper=lambda x: x["q"].upper(),
6)
7chain.invoke({"q": "hello"})
8# {'original': {'q': 'hello'}, 'upper': 'HELLO'}
9

结构化输出(对应 zod parse)

1from pydantic import BaseModel
2
3class Movie(BaseModel):
4    title: str
5    year: int
6
7structured = llm.with_structured_output(Movie)
8print(structured.invoke("推荐一部 2010 年后的科幻电影"))
9# Movie(title='星际穿越', year=2014)
10

工具调用(Agent 的地基)

1from langchain_core.tools import tool
2
3@tool
4def get_weather(city: str) -> str:
5    """查询城市天气。"""
6    return f"{city} 晴,25℃"
7
8llm_with_tools = llm.bind_tools([get_weather])
9resp = llm_with_tools.invoke("北京天气")
10print(resp.tool_calls)
11# [{'name': 'get_weather', 'args': {'city': '北京'}, ...}]
12

多轮历史

1from langchain_core.chat_history import InMemoryChatMessageHistory
2from langchain_core.runnables.history import RunnableWithMessageHistory
3from langchain_core.prompts import MessagesPlaceholder
4
5prompt = ChatPromptTemplate.from_messages([
6    ("system", "你是助手"),
7    MessagesPlaceholder("history"),
8    ("human", "{question}"),
9])
10base = prompt | llm | StrOutputParser()
11
12_store = {}
13def get_history(sid: str):
14    return _store.setdefault(sid, InMemoryChatMessageHistory())
15
16chat = RunnableWithMessageHistory(
17    base, get_history,
18    input_messages_key="question", history_messages_key="history",
19)
20chat.invoke({"question": "我叫小明"}, config={"configurable": {"session_id": "u1"}})
21

稳健性三件套

1chain = chain.with_retry(stop_after_attempt=3).with_fallbacks([backup_chain])
2config = {"tags": ["prod"], "metadata": {"user_id": "u1"}}
3

给前端的提示

把 Runnable 当成 Observable:可以组合、可以 stream、可以 batch、可以 with_retry。LCEL 的 | 就是 pipe。


04 RAG 全链路 · 第 3–4 周

RAG = 离线索引(加载 → 切分 → 向量化 → 入库)+ 在线查询(检索 → 重排 → 拼 Prompt → 生成 → 引用)。下面七个环节,每个都给实现和坑。

阶段做什么失败会怎样
索引把文档变成可检索的向量条目检索不到、检索到噪声
查询把问题变成答案,并标注出处答非所问、幻觉、无法追溯

1. 文档加载(Loading)

原理:所有来源统一成 Document(page_content, metadata)。metadata 是后面过滤、引用、去重的命脉。

1from langchain_community.document_loaders import (
2    PyPDFLoader, WebBaseLoader, TextLoader, DirectoryLoader,
3)
4
5# 单个 PDF:按页生成 Document,metadata 自带 source/page
6docs = PyPDFLoader("handbook.pdf").load()
7
8# 目录批量
9docs = DirectoryLoader(
10    "./docs", glob="**/*.txt",
11    loader_cls=TextLoader, loader_kwargs={"encoding": "utf-8"},
12).load()
13
14# 网页
15docs = WebBaseLoader(["https://example.com/a", "https://example.com/b"]).load()
16
17for d in docs[:3]:
18    print(d.metadata, d.page_content[:80])
19

坑

2. 切分(Splitting)

原理:embedding 有长度限制,检索粒度也要小于语义单元。分块质量决定 RAG 上限。

1from langchain_text_splitters import (
2    RecursiveCharacterTextSplitter, MarkdownHeaderTextSplitter,
3)
4
5splitter = RecursiveCharacterTextSplitter(
6    chunk_size=800,        # 中文按“字符”算,约 400~600 token 量级
7    chunk_overlap=120,     # 10%~15%
8    separators=["\n\n", "\n", "。", "!", "?", ";", ",", " ", ""],
9)
10chunks = splitter.split_documents(docs)
11print(len(chunks), chunks[0].metadata)
12

Markdown 保留标题层级(标题写进 metadata,检索时更好定位):

1md_splitter = MarkdownHeaderTextSplitter(
2    headers_to_split_on=[("#", "h1"), ("##", "h2"), ("###", "h3")]
3)
4md_chunks = md_splitter.split_text(markdown_text)
5

坑

  • chunk_size 太小 → 语义断裂;太大 → 噪声多、召回不准。用真实问题调参。
  • 表格、代码块被切断 → 先按结构切,再按长度切。
  • 中文别用英文默认分隔符,会切出整段超长块。

3. 向量化(Embedding)

原理:双塔模型把文本映射为向量,语义近则余弦相似度高。索引和查询必须用同一个 embedding 模型。

1from langchain_openai import OpenAIEmbeddings
2
3emb = OpenAIEmbeddings(model="text-embedding-3-small", dimensions=512)
4
5# 本地/免费方案(需 pip install langchain-huggingface sentence-transformers)
6# from langchain_huggingface import HuggingFaceEmbeddings
7# emb = HuggingFaceEmbeddings(model_name="BAAI/bge-m3")
8

开发期加缓存,别反复花钱:

1from langchain.embeddings import CacheBackedEmbeddings
2from langchain.storage import LocalFileStore
3
4cached_emb = CacheBackedEmbeddings.from_bytes_store(
5    emb, LocalFileStore("./emb_cache"), namespace=emb.model
6)
7

坑

  • 换 embedding 模型 = 必须全量重建索引,维度不同会直接报错。
  • 部分模型要求 query 加指令前缀(如 BGE 系列),索引与查询写法要对齐。

4. 入库(VectorStore)

1from langchain_chroma import Chroma
2
3vectorstore = Chroma(
4    collection_name="handbook",
5    embedding_function=cached_emb,
6    persist_directory="./chroma_db",
7)
8
9vectorstore.add_documents(chunks)          # 内部自动向量化并落盘
10print(vectorstore.similarity_search_with_score("年假多少天", k=4))
11

其他选型:FAISS(纯本地、快)、PGVector(要事务/权限/多租户)、Milvus / Qdrant(大规模)。

坑

  • 重复导入要固定 ids 做 upsert;删文档要同步 delete(ids)。
  • 生产别把“全量重建”当更新策略。

5. 检索(Retrieval)

1# 基础 TopK
2retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
3
4# MMR:兼顾相关性和多样性,避免 4 条都是重复内容
5retriever = vectorstore.as_retriever(
6    search_type="mmr",
7    search_kwargs={"k": 4, "fetch_k": 20, "lambda_mult": 0.5},
8)
9
10# 相似度阈值
11retriever = vectorstore.as_retriever(
12    search_type="similarity_score_threshold",
13    search_kwargs={"score_threshold": 0.3, "k": 4},
14)
15
16# metadata 过滤(多租户/权限/部门,非常关键)
17retriever = vectorstore.as_retriever(
18    search_kwargs={"k": 4, "filter": {"dept": "hr"}}
19)
20

坑

  • k 太小漏召回,太大淹没有效信息。
  • filter 字段要建索引;问题与文档术语不一致时,先做查询改写。

6. 后处理 / 重排(Rerank)

原理:向量召回是双塔(快但粗),rerank 是 cross-encoder(慢但准)。召回 20 条 → 重排取 4 条。

1from langchain.retrievers import ContextualCompressionRetriever
2from langchain_cohere import CohereRerank   # 国内可用 BGE-reranker / DashScope gte-rerank
3
4reranker = CohereRerank(model="rerank-multilingual-v3.0", top_n=4)
5rerank_retriever = ContextualCompressionRetriever(
6    base_compressor=reranker, base_retriever=retriever
7)
8

长上下文重排(把最相关的放头尾,利用“中间遗忘”):

1from langchain_community.document_transformers import LongContextReorder
2
3reordered = LongContextReorder().transform_documents(docs)
4

坑

rerank 是延迟大头。先量化收益,再决定是否上;top_n 不要比喂给模型的条数还大。

7. 生成 + 引用(Generation)

1from langchain_core.runnables import RunnableParallel, RunnablePassthrough
2from langchain_core.output_parsers import StrOutputParser
3from langchain_core.prompts import ChatPromptTemplate
4
5def format_docs(docs):
6    return "\n\n".join(
7        f"[{i+1}] (来源:{d.metadata.get('source')} p.{d.metadata.get('page')})\n{d.page_content}"
8        for i, d in enumerate(docs)
9    )
10
11prompt = ChatPromptTemplate.from_messages([
12    ("system",
13     "你是企业知识库助手。只依据给定资料回答,资料不足就说“根据现有资料无法确定”。"
14     "回答后用 [1][2] 标注引用片段。"),
15    ("human", "资料:\n{context}\n\n问题:{question}"),
16])
17
18rag = (
19    RunnableParallel(
20        context=rerank_retriever | format_docs,
21        question=RunnablePassthrough(),
22        docs=rerank_retriever,          # 同时把原始文档带出来做引用
23    )
24    | prompt | llm | StrOutputParser()
25)
26
27answer = ""
28for chunk in rag.stream("年假怎么算?"):
29    answer += chunk
30    print(chunk, end="", flush=True)
31

多轮 RAG 要先把追问改写成独立问题,否则“那它呢?”检索不到:

1condense = (
2    ChatPromptTemplate.from_messages([
3        ("system", "根据历史把追问改写成独立完整的问题,只输出问题。"),
4        ("human", "历史:\n{history}\n追问:{question}"),
5    ]) | llm | StrOutputParser()
6)
7

坑

  • 不约束“只依据资料”就必然幻觉。
  • 引用编号必须和 format_docs 的编号一致。
  • context 超长要裁剪或分级(stuff → map_reduce)。

经典写法

旧教程常见 create_stuff_documents_chain + create_retrieval_chain,1.x 中在 langchain-classic。能用,但上面的手动 LCEL 更透明,也更容易加引用和流式。


05 高级检索 · 第 5 周

基础 RAG 跑通后,提分通常来自这里。按收益排序:混合检索 → 重排 → 查询改写 → 父子文档。

混合检索(向量 + BM25)

1from langchain_community.retrievers import BM25Retriever
2from langchain.retrievers import EnsembleRetriever  # 1.x: langchain_classic.retrievers
3
4bm25 = BM25Retriever.from_documents(chunks, k=4)   # 中文需接 jieba 分词
5vec = vectorstore.as_retriever(search_kwargs={"k": 4})
6hybrid = EnsembleRetriever(retrievers=[bm25, vec], weights=[0.4, 0.6])
7

专有名词、型号、人名用 BM25 补足向量的短板。

多查询改写(Multi-Query)

1from langchain.retrievers.multi_query import MultiQueryRetriever
2
3mq = MultiQueryRetriever.from_llm(retriever=vec, llm=llm)
4

LLM 生成 3 个不同问法,并行检索后去重,提升召回。

HyDE(假设文档嵌入)

1def hyde_search(q: str, k: int = 4):
2    fake_answer = (llm | StrOutputParser()).invoke(f"用一段话回答:{q}")
3    return vectorstore.similarity_search(fake_answer, k=k)
4

问题太短、太口语化时效果明显。

父子文档(Small-to-Big)

小块检索、大块喂模型:

1from langchain.retrievers import ParentDocumentRetriever
2from langchain.storage import InMemoryStore
3
4parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000)
5child_splitter = RecursiveCharacterTextSplitter(chunk_size=400)
6store = InMemoryStore()
7
8pdr = ParentDocumentRetriever(
9    vectorstore=vectorstore, docstore=store,
10    child_splitter=child_splitter, parent_splitter=parent_splitter,
11)
12pdr.add_documents(docs)
13

Self-Query(自然语言转 metadata 过滤)

“2023 年 HR 部门的制度”自动拆出 filter={"dept":"hr","year":2023},用 SelfQueryRetriever.from_llm + 字段描述实现。适合元数据规范的业务库。

Agentic RAG

检索 → 相关性打分 → 不合格就改写问题重查 → 合格才生成。这是 Self-RAG / CRAG 的核心思想,下一章用 LangGraph 实现。


06 评估与上线 · 第 6 周

没有评估的 RAG 优化全是玄学。先建 30~100 条黄金问答,再谈调参。

看哪些指标

侧指标回答什么问题
检索Recall@k / Hit Rate / MRR该找到的文档找到了吗
检索Context Precision / Recall召回的上下文准不准、全不全
生成Faithfulness答案是否忠于资料
生成Answer Relevancy / Correctness是否答到点上、与标准答案一致

RAGAS 案例

1from datasets import Dataset
2from ragas import evaluate
3# metrics 在新版里是类,需要实例化
4from ragas.metrics import Faithfulness, ResponseRelevancy, LLMContextRecall
5
6data = Dataset.from_list([{
7    "question": "年假多少天",
8    "answer": rag.invoke("年假多少天"),
9    "contexts": [d.page_content for d in rerank_retriever.invoke("年假多少天")],
10    "ground_truth": "入职满一年 5 天,逐年递增",
11}])
12result = evaluate(data, metrics=[Faithfulness(), ResponseRelevancy(), LLMContextRecall()])
13print(result)
14

每次改切分、embedding 或 rerank,都跑一遍。LangSmith 的 Datasets / Experiments 可以管理这套回归测试。

用 FastAPI 上线

1import json
2from fastapi import FastAPI
3from fastapi.responses import StreamingResponse
4
5app = FastAPI()
6
7@app.post("/chat")
8async def chat(q: str):
9    async def gen():
10        async for chunk in rag.astream(q):
11            yield f"data: {json.dumps({'delta': chunk}, ensure_ascii=False)}\n\n"
12        yield "data: [DONE]\n\n"
13    return StreamingResponse(gen(), media_type="text/event-stream")
14

工程化清单

  • astream_events 做细粒度事件;.with_retry()、超时、限流、降级模型。
  • LLM 与 embedding 双层缓存,成本大头常在 embedding 和 rerank。
  • LangSmith 追踪:LANGSMITH_TRACING=true + LANGSMITH_API_KEY,用来定位“是检索错了还是生成错了”。
  • 知识库增量 upsert + 删除;每天全量重建不可持续。

07 LangGraph 与 Agent · 第 7 周

当流程需要分支、循环、人工审批和断点续跑时,LCEL 就不够了。LangGraph 用“状态 + 节点 + 边”表达,像 Redux。

最小图

1from typing import Annotated, TypedDict
2from langgraph.graph import StateGraph, START, END
3from langgraph.graph.message import add_messages
4
5class State(TypedDict):
6    messages: Annotated[list, add_messages]
7
8def chatbot(state: State):
9    return {"messages": [llm.invoke(state["messages"])]}
10
11g = StateGraph(State)
12g.add_node("chatbot", chatbot)
13g.add_edge(START, "chatbot")
14g.add_edge("chatbot", END)
15app = g.compile()
16print(app.invoke({"messages": [("user", "你好")]}))
17

自适应 RAG(条件边 + 循环)

1class RAGState(TypedDict):
2    question: str
3    docs: list
4    tries: int
5
6def retrieve(s): return {"docs": retriever.invoke(s["question"])}
7
8def grade(s):
9    ok = bool(s["docs"])
10    return "generate" if ok else "rewrite"
11
12def rewrite(s):
13    return {"question": s["question"] + " 详细说明", "tries": s["tries"] + 1}
14
15g = StateGraph(RAGState)
16g.add_node("retrieve", retrieve)
17g.add_node("generate", lambda s: {"docs": s["docs"]})
18g.add_node("rewrite", rewrite)
19g.add_edge(START, "retrieve")
20g.add_conditional_edges("retrieve", grade, {"generate": "generate", "rewrite": "rewrite"})
21g.add_edge("rewrite", "retrieve")
22g.add_edge("generate", END)
23app = g.compile()
24

生产里 grade 用 LLM 做相关性判断,并加 tries 上限防止死循环。

存档与中断

1from langgraph.checkpoint.memory import MemorySaver
2
3app = g.compile(checkpointer=MemorySaver(), interrupt_before=["generate"])
4app.invoke(init, config={"configurable": {"thread_id": "u1"}})
5

thread_id 相当于会话 ID;checkpoint 让多轮、人工审批、断点续跑成为可能。

一行建 Agent(1.x)

1from langchain.agents import create_agent  # 旧版: langgraph.prebuilt.create_react_agent
2
3agent = create_agent(model=llm, tools=[search_kb], system_prompt="先查知识库再回答")
4

把检索封装成工具,Agent 自己决定何时查、查几次。


08 项目实战 · 第 8 周

选 1~2 个做完,比看十个教程有用。

企业知识库问答(推荐)

PDF / Markdown 目录 → 切分入库 → 混合检索 + rerank → 流式回答 + 引用跳转 → RAGAS 报告 → FastAPI + 前端 SSE。

代码库问答

按函数 / 类切分,metadata 存 file:line,回答直接给代码链接。

带工具的客服 Agent

知识库检索 + 订单查询 API + 工单创建,LangGraph 控制流程与人工审批。

文档对比助手

两个版本 diff 后分块,检索时按 version 过滤,回答指出差异条款。

交付物

GitHub 仓库(README 写清架构图、指标、成本)、演示视频、一页“踩坑与优化记录”。这三样就是你的作品集。


09 前端联调 · 你的主场

后端输出 SSE,前端用 ReadableStream 解析。Key 只放服务端,前端只管渲染与引用浮层。

1const res = await fetch("/chat", {
2  method: "POST",
3  headers: { "Content-Type": "application/json" },
4  body: JSON.stringify({ q: "年假怎么算" }),
5});
6
7const reader = res.body.getReader();
8const decoder = new TextDecoder();
9let buffer = "";
10
11while (true) {
12  const { value, done } = await reader.read();
13  if (done) break;
14  buffer += decoder.decode(value, { stream: true });
15
16  const lines = buffer.split("\n\n");
17  buffer = lines.pop() ?? "";
18  for (const line of lines) {
19    if (!line.startsWith("data: ")) continue;
20    const data = line.slice(6);
21    if (data === "[DONE]") return;
22    console.log(JSON.parse(data).delta);
23  }
24}
25
  • 用 Next.js Route Handler 做 BFF 代理,密钥只放服务端。
  • 引用数据单独走一个事件,前端渲染成可点击的来源列表。
  • 记得处理断流、重连、取消(AbortController)和错误提示。

10 避坑清单

这些坑基本每个人都会踩一遍,提前看一眼能省两周。

  1. 别从 Agent 开始。 先 LCEL,再 RAG,再 LangGraph。顺序反了会一直“调不通”。
  2. 教程版本对不上时,先看 pip show langchain,再看官方文档当前版。
  3. 中文切分按字符算,chunk_size=800 别照搬英文教程的 token 数。
  4. 换 embedding 模型必须重建索引,先把维度写进配置。
  5. 没有 metadata 的 RAG 是玩具:权限、部门、时间、来源都得进 metadata。
  6. 不加“只依据资料回答”的约束,幻觉率会高得离谱。
  7. 先建 30 条黄金评测集再调参,不然全是玄学。
  8. 内存历史只能开发用,MemorySaver / InMemoryChatMessageHistory 生产要换 Redis / Postgres。
  9. 成本大头常在 embedding 和 rerank,不在生成;开发期一定要开缓存。
  10. Prompt 注入:检索到的文档也可能含恶意指令,系统提示要明确“资料只是数据”。
  11. 更新知识库用增量 upsert + 删除,不要每天全量重建。
  12. 上线前加超时、重试、降级,LLM 不是稳定依赖。

11 自检清单

能全部做到,就算出师。

  • 能解释 LCEL 中 | 的数据流,能手写 RunnableParallel
  • 能独立搭一条带引用和流式的 RAG
  • 能说清 chunk_size / overlap / k / fetch_k / top_n 各自影响什么
  • 能设计 metadata 方案支持权限过滤
  • 能跑 RAGAS 并用分数指导优化
  • 能用 LangGraph 写带条件边和 checkpoint 的流程
  • 能把服务用 FastAPI 包装成 SSE 接口并对接前端
  • 能用 LangSmith 定位“是检索错了还是生成错了”

按自己的节奏推进,每周至少留下一个可运行的 demo。

Python 3.11 · LangChain 1.x · RAG


参考文档


《LangChain 学习路线 · 前端工程师的 8 周计划》 是转载文章,点击查看原文。


相关推荐


WorkBuddy 自动化工作流实测:从分镜脚本到 MP4 成片的 18 步复盘
小虎AI生活2026/11/8

一次不掺水的工具实测复盘:输入是 3 组自然语言提示词,输出是 4 张 3D 分镜图 + 一条带配音字幕的竖屏 MP4。本文按 18 个步骤还原 WorkBuddy 如何自主规划工作流、自愈安装缺失环境、逐帧质检并修复 drawtext 字幕缺字问题,末尾也写了没能顺畅播放的那一步。 我是小虎,浙大计算机本硕,破局行动家,《AI超级个体——一人公司完全指南》作者,专注于AI培训、超级个体打造、公司提效陪跑。 以前做条带货视频,普通 AI 只能给你写写分镜文案,找画图、配音、剪辑还得自己一个


WPS如何打开:选中单元格,导航栏显示内容
vipers_2026/10/31

问题:我打开Excel表之后,鼠标选中一个单元格,然后上方导航栏处,没有出现单元格内的内容。 解决办法: 在导航栏的“视图”,选项卡中,选择打开“编辑栏”。 1、原本的样子如下: 2、路径如下: 3、完成样子如下:


AI 编程智能体 09:零门槛调用教程
软件科学-郝学胜2026/10/23

AI 编程智能体 09:零门槛调用教程 Bilibili 同步视频✨ 前置环境:规范搭建专属本地开发环境1. 开发工具配置2. 依赖安装:拒绝全局 pip! 🚀 核心实操:LangChain 极简调用本地 Ollama 模型1. 基础模型调用:两种核心模式全覆盖2. 核心参数详解:temperature 调参秘籍💡3. 进阶玩法:实现带上下文的多轮对话 📊 本地模型选型指南:大模型VS轻量模型1. 超大参数模型(百亿级)2. 轻量高效模型(7B量级) 🎯 后续进阶方向💻


汽车免拆诊断案例 | 2016款奔驰GLA200车仪表上的多个灯光指示灯偶尔异常点亮
虹科Pico汽车示波器2026/10/17

故障现象  一辆2016款奔驰GLA200车,搭载270 910发动机,累计行驶里程约为15万km。该车仪表上的多个灯光指示灯偶尔异常点亮(图1),且室外温度无法显示,燃油存量也无法指示。 图1 故障出现时的仪表 故障诊断 用故障检测仪检测,发现仪表(A1)中存储有“U001988 车内控制器区域网络(CAN)通信存在故障。总线关闭”等多个通信类故障代码,而其他多个控制模块中均存储有故障代码“U015587 与仪表盘的通信存在故障。信息缺失”,由此初步判断仪表偶尔失去通信,可能的原因有:


【C++】类与对象(末):static、友元与拷贝优化
H.莓飛2026/10/13

【C++】类与对象(末):static、友元与拷贝优化 🔥 H.莓飛: 个人主页 ❄️个人专栏:「C++」「数据结构」「Linux系统编程」 ✨ 心不畏死,踏屍前行。 📦 代码仓库:cocatrice_csdn_code 📖 博主简介: 概览 构造函数体与初始化列表初始化顺序与未初始化的内置类型成员类型转换与 explicitstatic 成员变量与 static 成员函数静态成员的典型用途友元函数与友


从「工具调用」到「Code Mode」:AI Agent 正在经历一场范式转移
HeteroCat2026/10/5

2026 年,Cloudflare、Anthropic、Pi、Pydantic 四家独立指向同一个结论:别再给模型描述工具了,给它一个运行时。 一、一个被忽视的隐性成本 先看一组数字。 GitHub 官方 MCP 服务器在连接时,会把约 55,000 个 token 的工具 schema 塞进上下文。而同样功能的 gh CLI,通过 --help 发现同样的能力面只需要约 200 个 token——相差 275 倍。 Anthropic 在自己的一篇工程博客里承认得更直接:「工具定义在优化前


《HarmonyOS 7 Flutter 三方插件鸿蒙化开发手记》05:从本地能跑到真正可发布的 OHOS 插件【鸿蒙心迹】
李游Leo2026/9/27

example 能跑,就等于插件可以发布了吗?还差得远。 前四篇我们把插件从无到有搭起来了: 01:插件被 HarmonyOS 识别02:Dart 和 ArkTS 通信03:接入系统能力04:生命周期和权限 现在 example 能跑了。但能不能发布给别人用? 差得远。example 能跑只是第一步,真正发布还要处理版本兼容、错误码、测试、文档这些事。 一、先想清楚:example 能跑和可发布差在哪 先把最基础的问题想明白。 对比example 能跑可发布插件版本只测当前 SDK要兼容多


CentOS 7 虚拟机磁盘 I/O 卡顿排查实录:从 iostat 异常到虚拟盘后端故障的完整定位
lqg_zone2026/9/20

一台运行 MySQL、ClickHouse、MongoDB、MinIO 等多套服务的 CentOS 7 虚拟机出现"磁盘读写缓慢、数据库查询卡顿"。本文完整记录了从建立观测、指标判读、双盘对照、落盘分布定位,到最终用"同文件系统重写"实现零扩容、停机 1 分钟内完成数据迁移的全过程。 关键词:CentOS 7 / VMware PVSCSI / iostat / await / LVM 落盘分布 / XFS / 无损迁移 前言:问题现象 现象描述: 数据库查询与写入明显变慢,体感"响应恢复不


还在手动配 SSL 证书?这个 75K Star 的 Web 服务器让 HTTPS 自动到起飞
Hey_AI_Coder2026/9/12

摘要: 配置 HTTPS 证书有多痛苦?申请、验证、续期、重启,每一步都可能出错。Caddy 直接把这些全自动化了 服务器部署好了,网站能访问了,但浏览器地址栏显示「不安全」。你需要配 HTTPS,于是开始折腾 Let's Encrypt,申请证书、验证域名、配置 Nginx、重启服务。好不容易搞定了,三个月后证书过期,网站又挂了。 更糟的是,你有十几个站点,每个都要配证书,每个都要续期。某天凌晨三点,运维电话打来:「证书过期了,网站打不开」。 HTTPS 是必须的,但配证书的过程太痛苦了。


从 Token 到蒸馏:一步步理解大模型如何工作
杨杨杨大侠2026/9/4

本文面向刚开始了解大模型的读者,以本机运行的 Qwen2.5 0.5B 为例,解释 Token、参数、Transformer、训练、蒸馏和量化之间的关系。 先用一句话概括大模型: 大模型使用训练得到的参数,根据已有 Token,反复预测下一个 Token。 1. 一个模型里有什么 模型不只是一个权重文件。完整运行通常需要三部分: 结构配置:规定模型有多少层、每层多宽。 Tokenizer 和词表:负责文字与 Token ID 之间的转换。 参数:训练得到的大量数字,包括权重矩阵、偏置和归一

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2026 聚合阅读