LangChain / LlamaIndex 二选一

这两个东西干嘛

它们是 LLM 应用的抽象层：把 RAG / Agent / Memory 这些常见模式封装成"乐高积木"。

• LangChain：覆盖最广，组件最多，复杂度最高
• LlamaIndex：专注 RAG / 文档索引，更聚焦

LangChain 简单例子

pip install langchain langchain-anthropic

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate

llm = ChatAnthropic(model="claude-sonnet-4-6")

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是 Python 老师"),
    ("human", "{question}"),
])

chain = prompt | llm
result = chain.invoke({"question": "装饰器是什么？"})
print(result.content)

prompt | llm 这种"管道"语法是 LangChain 的核心——把组件串起来。

LangChain 做 RAG（简化版）

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.document_loaders import TextLoader

# 加载 + 切块
docs = TextLoader("doc.md").load()
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=80)
chunks = splitter.split_documents(docs)

# 向量化 + 存储
embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-large-zh-v1.5")
vectorstore = Chroma.from_documents(chunks, embeddings)

# 检索 + 生成
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt | llm
)

answer = chain.invoke("Python 装饰器是什么？")

10 行做完上一篇 80 行干的事——当组件需求标准时，LangChain 真省力。

LlamaIndex：专注文档检索

pip install llama-index llama-index-llms-anthropic

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.anthropic import Anthropic
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import Settings

Settings.llm = Anthropic(model="claude-sonnet-4-6")
Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-large-zh-v1.5")

# 一行搞定整个索引
docs = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(docs)

# 一行搞定查询引擎
engine = index.as_query_engine(similarity_top_k=5)
response = engine.query("装饰器是什么？")
print(response)

# 看看引用了哪些来源
for node in response.source_nodes:
    print(node.metadata, node.score)

更简洁。

抽象层的代价

• 学习曲线：要学库的概念（Runnable / Chain / Tool / Agent / ...）
• 调试难：错误嵌套很深，traceback 不友好
• 版本变动大：LangChain 半年大改一次 API
• 黑盒：不容易精确控制每个 prompt

我的建议

一个折中策略：极薄封装

不靠任何框架，自己写 200 行：

class Retriever:
    def search(self, query, k=5): ...

class LLM:
    def chat(self, messages): ...

class RAGPipeline:
    def __init__(self, retriever, llm):
        self.retriever = retriever
        self.llm = llm
    def ask(self, q):
        ctx = self.retriever.search(q)
        return self.llm.chat([...])

代价：自己写 200 行；收益：完全可控、好调试、不被框架绑架。

生产代码我推荐这条路——只在原型快速验证时用框架。

下一篇讲 AI Agent。