构建简易LangChain框架，问句何在？

说实话，想玩LLM却被一堆抽象绕晕了真是伤脑筋。

我先把Zui原始的demo敲出来裸写一遍。

先搞个FakeLLM，啥也不干，只是把你给的prompt原样返回。

class BaseLLM:
    def invoke -> str:
        raise NotImplementedError
class FakeLLM:
    def __init__:
        self.resp = resp or {}
    def invoke:
        for k,v in self.resp.items:
            if k in prompt:
                return v
        return f" {prompt}..."

跑通了？好啊，接下来碰到“重复造抽象”这点疼，就把LangChain拉进来。

现代版的LangChain推荐用LangGraph的create_react_agent。

它把Agent建模成状态图，比我们手写的while循环强大多了——支持分支、并行、checkpoint回放。

下面给出一个完整的MiniLangChain实现，和真货对照一下你会立刻明白两者之间的映射关系。

先来段SDK裸写：

from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
# 切片
splitter = RecursiveCharacterTextSplitter
docs = splitter.create_documents()
# 向量化+入库
vectorstore = Chroma.from_documents)
retriever = vectorstore.as_retriever
# RAG 链
rag_prompt = ChatPromptTemplate.from_template(
    "基于以下上下文回答问题。若上下文没有答案，请回答\"不知道\"。

"
    "上下文:
{context}

问题: {question}"
)
def format_docs:
    return "
---
".join
rag_chain = (
    {"context": retriever | format_docs,
     "question": RunnablePassthrough}
    | rag_prompt
    | ChatOpenAI
    | StrOutputParser
)
print)

关键差异在于：我们只用了Runnable组合，而MiniLangChain把所有底层抽象压缩到几行代码里。

class BaseLLM:
    @abstractmethod
    def invoke -> str: ...
class OpenAILLM:
    def __init__:
        from openai import OpenAI
        self.client = OpenAI
        self.model = model
    def invoke:
        resp = self.client.chat.completions.create(
            model=self.model,
            messages=
        )
        return resp.choices.message.content
class Tool:
    def __init__:
        self.name=name; self.description=description; self.func=func
    def run: return self.func
def calculator->str:
    try: return str)
    except Exception as e: return f"计算错误:{e}"
def search->str:
    fake_db={"天气":"北京今天晴，25℃","股价":"苹果今日收盘 $150"}
    for k,v in fake_db.items:
        if k in query: return v
    return "未找到相关信息"
CALC_TOOL=Tool
SEARCH_TOOL=Tool

记住这里只有一个契约：字符串进，字符串出. 其它一切dou是围着它变形。

from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
@tool
def calculator->str:
    """计算数学表达式"""
    try: return str)
    except Exception as e: return f"计算错误:{e}"
@tool
def search->str:
    """搜索实时信息"""
    fake={"天气":"北京今天晴，25℃","股价":"苹果收盘 $150"}
    for k,v in fake.items:
        if k in query:return v
    return "未找到"
agent = create_react_agent(
    ChatOpenAI,
    tools=,
)
result = agent.invoke]})
print

注意这里返回的是消息列表，一行代码就Neng生成一个完整的 ReAct 智Neng体。比我们手写的 while 循环强太多啦——支持分支、并行，还Neng checkpoint 回放。

真实向量库会调用 Embedding 模型算余弦相似度，这里我们用词集合交并比来模拟，实现geng轻量。

class Document:
    def __init__:
        self.content=content; self.metadata=metadata or {}
class VectorStore:
    def __init__: self.docs=
    def add: self.docs.extend
    @staticmethod
    def _tokens: 
        import re; return set))
    def search:
        qtok=self._tokens
        scores=
        for d in self.docs:
            dtok=self._tokens
            if not dtok: continue
            score=len/len
            scores.append)
        scores.sort
        return  if s>0]

把它包装成 Retriever，就Ke以直接塞进 LCEL 管道：

class Retriever:
   def __init__: self.v=vstore; self.k=k
   def invoke:
       docs=self.v.search
       if not docs:return ""
       return "
---
".join

# 初始化框架
fake_llm=FakeLLM({
   "LangChain":"LangChain 是让 LLM 应用组件化的 Python 框架",
   "首dou":"北京"
})
app=MiniLangChain
# 添加工具
app.add_tool; app.add_tool
# 把知识喂进去
app.ingest("""LangChain 于 2023 年由 Harrison Chase 创建，
核心抽象有 LLM、PromptTemplate、Chain、Memory、Tool 与 Agent。
配套产品 LangSmith 提供 tracing 与调试Neng力。
后续推出 LangGraph 用状态机替代线性 Chain，geng适合复杂 Agent。""")
# RAG 查询演示
rag_fn=app.rag_chain
print)
# 带记忆对话演示
print)
print)
# Agent 调工具演示
agent=app.agent
print)

kan到没？从Zui原始的 FakeLLM → Prompt → LLM → Parser → Tool → Loop 一步步拼装成了完整可运行的小框架。每一步dou对应真实 LangChain 中的同名抽象，只是我们自己实现了一遍而Yi。

说实话，hen多人直接扔进去整个生态，却忘了自己的业务到底需要哪块功Neng。

A：Ru果你只需要一次性召回几段文档，用上面的 VectorStore 完全够用；不必装配千层插件。

B：Ru果你的业务需要多轮记忆、工具调用甚至自定义状态机，那就真的该上 LangGraph 和 LangSmith 了。

C：别忘了真正生产环境里还有流式输出、异步调用以及 checkpoint 持久化，这些dou是 LangChain Yi经封装好的坑位。

CIA——先判断需求，再选技术栈。这样既省钱又省心。

哈哈，其实玩转 LLM 就像玩乐高，一块块积木随意拼接才有乐趣。

Coding 时别总想着“一站式解决”，先写个Zui小可运行例子，再慢慢加层抽象——这就是我一路走来的经验教训。

咱就是说Ru果你现在Yi经Neng跑通上面的 MiniLangChain，那后面去官方文档学习 LCEL 与 LangGraph 时会轻松不少；不然直接硬撸代码，只会越搞越乱。

# 小结 * 基础抽象只有一个：BaseLLM.invoke * RAG＝Retriever + Prompt + LLM + Parser 的管道组合 * Agent＝ReAct 循环+ Tool 集合 * Memory 把历史拼进 Prompt，就是Zui朴素的对话持久化

P.S. Ru果你真的想在生产环境里玩转这些高级特性，记得装上 LangSmith 来追踪每一步日志，否则调试起来会hen痛苦——但那是下一篇文章要聊的话题啦！懂吗？哈哈，祝玩得开心~