02. LangChain 入门与 RAG 实战¶

用户提问 → 组装 Prompt → 调用 LLM → 解析输出 → 返回结果

┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
│ ① 加载   │ →  │ ② 切分   │ →  │ ③ 向量化  │ →  │ ④ 存储   │ →  │ ⑤ 检索   │ →  │ ⑥ 生成   │
│ 文档     │    │ 文本     │    │ Embedding│    │ 向量库   │    │ 相似搜索  │    │ LLM回答  │
└─────────┘    └─────────┘    └─────────┘    └─────────┘    └─────────┘    └─────────┘
   离线准备阶段（只做一次）                                      在线问答阶段（每次提问都走）

# 不用模板（硬拼接，容易出错）
prompt = "请根据以下内容回答：" + context + "\n问题：" + question

# 用模板（清晰、可复用）
template = """请根据以下内容回答用户的问题。
如果内容中没有答案，请说"我不确定"。

参考内容：{context}
用户问题：{question}
"""

# 建议在独立的 conda 环境中安装
conda create -n langchain python=3.11 -y
conda activate langchain

# 安装核心包
pip install langchain langchain-community langchain-openai chromadb

# 如果要用本地 Ollama 模型（免费方案）
pip install langchain-ollama

# 如果要加载 PDF 文件
pip install pypdf

# 如果要用 HuggingFace 的 Embedding 模型（免费）
pip install langchain-huggingface sentence-transformers

# === 第一个 LangChain 程序 ===
# 功能：调用 LLM 回答一个简单问题

# 导入 ChatOpenAI 类（支持 OpenAI 及兼容 API）
from langchain_openai import ChatOpenAI

# 初始化模型
# 如果你用 OpenAI 官方 API：
# llm = ChatOpenAI(model="gpt-4o-mini", api_key="你的key")

# 如果你用本地 Ollama（免费，推荐）：
llm = ChatOpenAI(
    model="qwen2.5:7b",               # Ollama 里下载的模型名
    base_url="http://localhost:11434/v1",  # Ollama 的 API 地址
    api_key="ollama",                  # Ollama 不需要真实 key，随便填
    temperature=0                      # 0 = 回答更稳定，不随机
)

# 调用模型回答问题
response = llm.invoke("什么是宏基因组学？用一句话解释。")

# 打印结果
print(response.content)
# 输出示例：宏基因组学是直接从环境样本中提取所有微生物的DNA进行测序分析的学科。

# === 完整 RAG 系统 ===
# 功能：加载 Markdown 文件 → 切分 → 向量化 → 存储 → 检索问答

# ============ 第1步：导入所有需要的模块 ============
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# ============ 第2步：加载文档 ============
# 从指定目录加载所有 .md 文件
loader = DirectoryLoader(
    path="./knowledge_base",       # 你的知识库目录
    glob="**/*.md",                # 匹配所有 .md 文件（** 表示递归子目录）
    loader_cls=TextLoader,         # 用纯文本加载器
    loader_kwargs={"encoding": "utf-8"}  # 指定编码，避免中文乱码
)
# 执行加载，返回 Document 对象列表
documents = loader.load()
print(f"✓ 加载了 {len(documents)} 个文档")

# ============ 第3步：文本切分 ============
# 把长文档切成小段（chunk）
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,       # 每段最多 500 个字符
    chunk_overlap=50,     # 相邻段之间重叠 50 个字符（避免切断句子丢失上下文）
    separators=["\n## ", "\n### ", "\n\n", "\n", "。", "；", " "]
    # 切分优先级：优先在标题处切 → 空行处切 → 句号处切
    # 这样能保证每段内容是完整的意思
)
# 执行切分
chunks = text_splitter.split_documents(documents)
print(f"✓ 切分成 {len(chunks)} 个文本块")

# ============ 第4步：向量化 + 存储到 ChromaDB ============
# 初始化 Embedding 模型（把文字变成数字向量）
# 方案A：用 OpenAI 的 Embedding（付费但效果好）
# embeddings = OpenAIEmbeddings(api_key="你的key")

# 方案B：用 Ollama 本地 Embedding（免费，推荐）
from langchain_ollama import OllamaEmbeddings
embeddings = OllamaEmbeddings(
    model="nomic-embed-text",  # Ollama 里的 Embedding 模型
    base_url="http://localhost:11434"
)

# 把所有文本块向量化并存入 ChromaDB
vectorstore = Chroma.from_documents(
    documents=chunks,                # 要存储的文本块
    embedding=embeddings,            # 用什么模型做向量化
    persist_directory="./chroma_db"  # 数据存在磁盘的位置（下次不用重新建）
)
print(f"✓ 向量数据库构建完成，共 {vectorstore._collection.count()} 条记录")

# ============ 第5步：构建检索问答链 ============
# 初始化 LLM（用 Ollama 本地模型）
llm = ChatOpenAI(
    model="qwen2.5:7b",
    base_url="http://localhost:11434/v1",
    api_key="ollama",
    temperature=0
)

# 自定义 Prompt Template（告诉 AI 怎么回答）
prompt_template = PromptTemplate(
    input_variables=["context", "question"],
    template="""你是一个生物信息学知识助手。请根据以下参考内容回答问题。
要求：
1. 只根据参考内容回答，不要编造
2. 如果参考内容中没有答案，请说"根据已有资料无法回答"
3. 用中文回答，术语附英文原文

参考内容：
{context}

问题：{question}

回答："""
)

# 创建检索问答链（把检索器 + LLM + Prompt 组装起来）
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,                                         # 用哪个语言模型
    chain_type="stuff",                               # stuff = 把所有检索到的内容塞进一个 prompt
    retriever=vectorstore.as_retriever(
        search_kwargs={"k": 3}                        # 每次检索返回最相关的 3 段
    ),
    chain_type_kwargs={"prompt": prompt_template},    # 使用自定义 Prompt
    return_source_documents=True                      # 同时返回来源文档（方便溯源）
)

# ============ 第6步：提问！ ============
question = "宏基因组分析的主要流程有哪些步骤？"
result = qa_chain.invoke({"query": question})

# 打印回答
print("=" * 50)
print(f"问题：{question}")
print(f"回答：{result['result']}")
print("=" * 50)

# 打印来源（可以看到 AI 参考了哪些文档片段）
print("\n参考来源：")
for i, doc in enumerate(result["source_documents"]):
    print(f"  [{i+1}] {doc.metadata.get('source', '未知')} ")
    print(f"      内容片段：{doc.page_content[:80]}...")

# ====== 第1步：安装 Ollama ======
# Linux：
curl -fsSL https://ollama.com/install.sh | sh

# ====== 第2步：下载模型 ======
# 下载对话模型（选一个，推荐 qwen2.5:7b，中文好）
ollama pull qwen2.5:7b       # 4.7GB，中文效果好
# 或者
ollama pull llama3.1:8b      # 4.7GB，英文强

# 下载 Embedding 模型（必须下，用于向量化）
ollama pull nomic-embed-text  # 274MB，小巧够用

# ====== 第3步：验证模型可用 ======
ollama list   # 查看已下载的模型
ollama run qwen2.5:7b "你好"  # 测试对话

# ====== 免费 RAG 完整配置（不花一分钱） ======

from langchain_openai import ChatOpenAI
from langchain_ollama import OllamaEmbeddings

# LLM：用 Ollama 本地模型（免费）
llm = ChatOpenAI(
    model="qwen2.5:7b",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Embedding：用 Ollama 本地 Embedding 模型（免费）
embeddings = OllamaEmbeddings(
    model="nomic-embed-text",
    base_url="http://localhost:11434"
)

# 向量数据库：ChromaDB（免费，本地存储）
# 加上上面4.2节的代码就是一个完整的免费 RAG 系统
# 总花费：0元

# === 不同场景的 Prompt Template ===

from langchain.prompts import PromptTemplate

# 场景1：严格问答（不让 AI 编造）
strict_qa_prompt = PromptTemplate(
    input_variables=["context", "question"],
    template="""请严格根据以下参考内容回答问题。
如果参考内容中找不到答案，请回答"无法确定"。

参考内容：{context}
问题：{question}
回答："""
)

# 场景2：生信面试模拟
interview_prompt = PromptTemplate(
    input_variables=["context", "question"],
    template="""你是一位生信面试教练。
根据参考资料，用面试回答的格式回答问题：
1. 先用一句话总结核心要点
2. 再分点展开（2-3个要点）
3. 最后举一个实际应用的例子

参考资料：{context}
面试问题：{question}
回答："""
)

# 场景3：多语言术语对照
bilingual_prompt = PromptTemplate(
    input_variables=["context", "question"],
    template="""根据以下内容回答问题。
要求：所有专业术语同时给出中文和英文，格式为"中文（English）"。

内容：{context}
问题：{question}
回答："""
)

# === 用 LCEL（LangChain Expression Language）串联 Chain ===
# LCEL 是 LangChain 推荐的新写法，用 | 符号串联步骤

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 初始化模型
llm = ChatOpenAI(
    model="qwen2.5:7b",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# 定义一个翻译 + 总结的串联 Chain
# 第一步：翻译
translate_prompt = ChatPromptTemplate.from_template(
    "把以下英文生信术语翻译成中文并解释：{term}"
)

# 第二步：简化
simplify_prompt = ChatPromptTemplate.from_template(
    "把以下解释用更通俗的白话重新说一遍，让完全没基础的人也能听懂：\n{text}"
)

# 用 | 串联：输入 → 翻译prompt → LLM → 解析文本 → 简化prompt → LLM → 输出
chain = translate_prompt | llm | StrOutputParser() | simplify_prompt | llm | StrOutputParser()

# 运行
result = chain.invoke({"term": "Metagenomic binning"})
print(result)

# === 个人知识库问答系统（完整版） ===
# 把你面试准备的知识库目录变成 AI 可问答的系统

import os
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import ChatOpenAI
from langchain_ollama import OllamaEmbeddings
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# ======== 配置区（根据你的实际情况修改） ========
KNOWLEDGE_DIR = "/home/user/面试/knowledge_base  知识库"  # 你的知识库路径
CHROMA_DIR = "/home/user/面试/my_vectordb"                # 向量库存储位置
OLLAMA_URL = "http://localhost:11434"                      # Ollama 地址

def build_knowledge_base():
    """构建向量知识库（只需运行一次）"""

    # 1. 加载所有 Markdown 文件
    loader = DirectoryLoader(
        path=KNOWLEDGE_DIR,
        glob="**/*.md",
        loader_cls=TextLoader,
        loader_kwargs={"encoding": "utf-8"},
        show_progress=True    # 显示加载进度条
    )
    docs = loader.load()
    print(f"加载了 {len(docs)} 个文档")

    # 2. 切分
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        separators=["\n## ", "\n### ", "\n\n", "\n", "。", " "]
    )
    chunks = splitter.split_documents(docs)
    print(f"切分成 {len(chunks)} 个文本块")

    # 3. 向量化 + 存储
    embeddings = OllamaEmbeddings(
        model="nomic-embed-text",
        base_url=OLLAMA_URL
    )
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory=CHROMA_DIR
    )
    print(f"知识库构建完成！共 {vectorstore._collection.count()} 条记录")
    return vectorstore

def ask(question, vectorstore=None):
    """向知识库提问"""

    # 如果没传入 vectorstore，就从磁盘加载已有的
    if vectorstore is None:
        embeddings = OllamaEmbeddings(
            model="nomic-embed-text",
            base_url=OLLAMA_URL
        )
        vectorstore = Chroma(
            persist_directory=CHROMA_DIR,
            embedding_function=embeddings
        )

    # 初始化 LLM
    llm = ChatOpenAI(
        model="qwen2.5:7b",
        base_url=f"{OLLAMA_URL}/v1",
        api_key="ollama",
        temperature=0
    )

    # 自定义 Prompt
    prompt = PromptTemplate(
        input_variables=["context", "question"],
        template="""你是[用户]的面试备考助手。请根据知识库中的内容回答问题。
要求：
1. 只基于提供的内容回答，不要编造
2. 如果涉及面试，给出面试回答模板
3. 术语给出英文原文

参考内容：
{context}

问题：{question}

回答："""
    )

    # 构建 QA Chain
    qa = RetrievalQA.from_chain_type(
        llm=llm,
        retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
        chain_type_kwargs={"prompt": prompt},
        return_source_documents=True
    )

    result = qa.invoke({"query": question})
    print(f"\n问：{question}")
    print(f"答：{result['result']}")
    print(f"\n来源：")
    for doc in result["source_documents"]:
        src = os.path.basename(doc.metadata.get("source", ""))
        print(f"  - {src}")
    return result

# ======== 使用方式 ========
if __name__ == "__main__":
    # 第一次运行：构建知识库（约需几分钟）
    # vs = build_knowledge_base()

    # 之后每次运行：直接提问（秒级响应）
    ask("宏基因组分析流程有哪些步骤？")
    ask("Shannon 指数和 Simpson 指数有什么区别？")
    ask("如果面试官问我随机森林的原理，我该怎么回答？")

from langchain_community.document_loaders import (
    TextLoader,           # 纯文本文件（.txt, .md）
    PyPDFLoader,          # PDF 文件（需要 pip install pypdf）
    CSVLoader,            # CSV 表格
    DirectoryLoader,      # 批量加载整个目录
    WebBaseLoader,        # 从网页加载（需要 pip install beautifulsoup4）
    UnstructuredFileLoader # 通用加载器（自动识别格式）
)

from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,  # 最常用，递归按分隔符切
    CharacterTextSplitter,           # 简单按字符数切
    MarkdownTextSplitter,            # 按 Markdown 标题切
    TokenTextSplitter                # 按 Token 数切
)

from langchain_community.vectorstores import (
    Chroma,    # ChromaDB（轻量，推荐入门用）
    FAISS,     # Facebook AI 相似度搜索
)

# 基础调用
chain = prompt | llm | StrOutputParser()
result = chain.invoke({"question": "..."})

# 带检索的 RAG
from langchain_core.runnables import RunnablePassthrough
chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)