【第2篇】LangChain的初步实践

LangChain

工程实践
环境配置
云端方案
API密钥管理

环境变量
LangSmith监控

可观测性
语义缓存

成本优化
本地部署
Ollama容器化

GGUF格式
HuggingFace

Transformers
量化技术

4bit/8bit
核心组件
模型接口
ChatModel

消息格式
Embeddings

语义向量
提示工程
PromptTemplate

变量绑定
FewShot

上下文学习
ExampleSelector

动态示例
LCEL编排
管道操作符|

函数复合
RunnableParallel

并行优化
自动批处理

流式传输
部署方案
开发阶段
Ollama快速启动
CPU/GPU混合推理
生产阶段
vLLM高并发
长上下文优化
多模态扩展
文生图
DALL-E 3 API
Stable Diffusion本地
图像理解
GPT-4V/Claude 3
本地Qwen-VL/LLaVA
编目工作流
OCR+Vision+Embedding

2.1 设置依赖环境：从开发到生产的工程基础

环境架构规划：

现代LLM应用开发需要区分开发环境 、测试环境 和生产环境。

2.1.1 云端托管方案（快速启动）

依赖管理的技术本质：
Python环境隔离
污染风险
系统Python

/usr/bin/python
全局site-packages
项目A

venv/envA
独立依赖集

LangChain 0.2.x

OpenAI 1.x
项目B

venv/envB
独立依赖集

LangChain 0.1.x

其他依赖
conda环境

ml-project
科学计算栈

PyTorch/CUDA

Transformers

基础环境配置：

# 创建隔离环境（必须使用）
python -m venv langchain-env
source langchain-env/bin/activate  # Linux/Mac
# 或 langchain-env\Scripts\activate  # Windows

# 核心依赖安装（分层架构）
pip install langchain-core          # 基础抽象（必须）
pip install langchain-openai        # OpenAI集成（可选）
pip install langchain-community     # 社区集成（推荐）
pip install langchain-anthropic     # Claude支持（可选）
pip install langchain-ollama        # 本地模型（可选）

环境变量安全配置（生产级实践）：

# 错误做法：硬编码密钥（安全风险）
os.environ["OPENAI_API_KEY"] = "sk-..."  # ❌ 会进入git历史

# 正确做法：使用python-dotenv管理环境变量
# 1. 创建 .env 文件（加入.gitignore）
"""
OPENAI_API_KEY=sk-...
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls-...
LANGCHAIN_PROJECT=my-library-project
"""

# 2. 代码中加载
from dotenv import load_dotenv
load_dotenv()  # 自动加载.env文件

# 3. 验证配置完整性
import os
required_vars = ["OPENAI_API_KEY"]
missing = [var for var in required_vars if not os.getenv(var)]
if missing:
    raise EnvironmentError(f"缺少环境变量: {missing}")

优化配置详解：

1. 智能缓存策略（Semantic Cache）

from langchain.globals import set_llm_cache
from langchain_community.cache import SQLiteCache, RedisCache
import langchain

# 本地SQLite缓存（开发环境）
set_llm_cache(SQLiteCache(database_path=".langchain.db"))

# 生产环境使用Redis（支持分布式）
# set_llm_cache(RedisCache(redis_url="redis://localhost:6379/0"))

# 缓存工作原理：
# 相同输入 → 计算hash → 查缓存 → 命中则直接返回，跳过API调用
# 实际节省：重复查询成本可降低80-95%

2. 可观测性配置（LangSmith）

# LangSmith不仅用于调试，更是生产监控的基础设施
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "ls-..."
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_PROJECT"] = "library-assistant-prod"  # 项目隔离

# 追踪内容包含：
# - 完整prompt（含系统消息）
# - token使用量（输入/输出）
# - 延迟指标（首token时间/总时间）
# - 错误堆栈（异常时）

2.1.2 本地私有化部署方案

技术架构对比：
本地方案
HTTP/Local
Python API
应用
Ollama/vLLM

本地GPU/CPU
Llama 3/Mistral

量化INT4/FP16
本地推理结果
应用
Hugging Face

Transformers
原生PyTorch模型
云端方案
HTTPS
应用
OpenAI API

云端GPU集群
GPT-4/GPT-3.5
返回生成结果

Ollama架构详解：

Ollama并非简单的模型包装器，而是本地LLM的容器化运行时：

# Ollama的核心组件：
# 1. Model Server (Go语言编写，监听11434端口)
# 2. Model File (Modelfile，类似Dockerfile，定义模型配置)
# 3. GGUF Loader (llama.cpp后端，高效CPU/GPU推理)

# 安装后验证
ollama --version  # 应显示0.1.x+
ollama list       # 查看已下载模型

# Modelfile示例（自定义模型行为）
cat > Modelfile << EOF
FROM llama3.1:8b
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM """你是图书馆参考咨询专家。遵循以下原则：
1. 所有推荐必须提供ISBN和馆藏位置
2. 不确定时承认无知，不编造信息
3. 使用中文回答"""
EOF

# 创建自定义模型
ollama create library-assistant -f Modelfile
ollama run library-assistant

LangChain集成代码：

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

# ChatOllama vs OllamaLLM的区别：
# - ChatOllama：原生支持消息格式（system/human/ai），推荐用于对话
# - OllamaLLM：字符串输入输出，兼容旧版代码

local_llm = ChatOllama(
    model="llama3.1:8b",
    base_url="http://localhost:11434",  # 可远程连接
    temperature=0.7,
    num_ctx=4096,  # 上下文窗口大小
    num_gpu=1,     # 使用GPU层数（自动）
    repeat_penalty=1.1,  # 重复惩罚
)

# 本地嵌入模型（替代OpenAI）
local_embeddings = OllamaEmbeddings(
    model="nomic-embed-text",  # 768维向量
    base_url="http://localhost:11434"
)

# 无缝替换：接口与云端模型完全一致
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是图书馆AI助手"),
    ("human", "{input}")
])

chain = prompt | local_llm | StrOutputParser()
response = chain.invoke({"input": "推荐Python入门书"})

⚠️ 关键纠正 ：temperature参数常被误解为"创意度"，实际上它控制概率分布的熵：

• 数学定义：P(wi)∝exp⁡(zi/T)P(w_i) \propto \exp(z_i / T)P(wi)∝exp(zi/T)，其中TTT为temperature
• T→0T \to 0T→0：退化为贪心解码（确定性输出）
• T→∞T \to \inftyT→∞：均匀分布（完全随机）
• 最佳实践：事实性任务用0-0.3，创意任务用0.7-1.0，但超过1.0通常导致质量下降

---

2.2 探索LangChain构建块

2.2.1 模型接口：LLM vs Chat Model的技术本质

LangChain提供三层抽象，但选择正确的抽象层至关重要：
模型接口层次
BaseLanguageModel

抽象基类
BaseLLM

文本补全接口
BaseChatModel

消息接口
OpenAI

text-davinci-003
HuggingFacePipeline

Legacy模型
ChatOpenAI

GPT-4/GPT-3.5
ChatAnthropic

Claude 3
ChatOllama

本地模型
Embeddings

文本向量化
OpenAIEmbeddings

text-embedding-3
OllamaEmbeddings

nomic-embed-text

技术对比：

特性	BaseLLM (Legacy)	BaseChatModel (现代)
输入格式	字符串	消息列表（System/Human/AI）
训练目标	文本补全	对话遵循（RLHF）
性能表现	需复杂prompt工程	原生支持指令遵循
成本效率	较高token消耗	优化了系统消息处理
推荐使用	❌ 仅兼容旧代码	✅ 所有新项目

正确使用示例：

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage

# Chat Model的标准消息格式
chat = ChatOpenAI(model="gpt-4", temperature=0.7)

messages = [
    SystemMessage(content="""
        你是{library_name}的智能馆员。角色设定：
        - 专业领域：{domain}
        - 服务原则：准确、友好、高效
        - 约束：不泄露用户借阅隐私
    """.format(library_name="国家科技图书馆", domain="计算机科学")),
    
    HumanMessage(content="查询我最近借阅的图书"),
    # 可选：添加历史消息维持上下文
    AIMessage(content="请提供您的读者证号以便查询..."),
    HumanMessage(content="证号：LIB2024001")
]

# 自动处理消息格式化（内部转换为模型特定格式）
response = chat.invoke(messages)

Embeddings技术原理：

嵌入模型将文本映射到高维向量空间，使得语义相似文本在空间中距离相近：

from langchain_openai import OpenAIEmbeddings

# text-embedding-3-large: 3072维，性能最优
# text-embedding-3-small: 1536维，性价比平衡
# text-embedding-ada-002: 旧版，1536维

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# embed_documents: 批量文档嵌入（使用批处理API，效率高）
texts = ["机器学习导论", "深度学习实战", "Python编程"]
vectors = embeddings.embed_documents(texts)
# 返回: [[0.01, -0.02, ...], [...], [...]] (1536维向量)

# embed_query: 单查询嵌入（优化了查询侧表示）
query_vector = embeddings.embed_query("AI学习资料")
# 返回: [0.015, -0.018, ...] (1536维)

# 余弦相似度计算语义相似性
import numpy as np
similarity = np.dot(query_vector, vectors[0]) / (
    np.linalg.norm(query_vector) * np.linalg.norm(vectors[0])
)

2.2.2 提示工程与模板：从手工到系统化

Prompt Template的架构设计：
提示工程层次
硬编码字符串

Hard-coded
模板化

PromptTemplate
示例学习

Few-shot
动态示例

ExampleSelector
提示词管理

Prompt Hub/版本控制
变量注入
部分绑定

partial
消息角色

System/Human

模板类型详解：

1. 基础模板（PromptTemplate）

from langchain_core.prompts import PromptTemplate

# 遗留：字符串模板（仅用于BaseLLM）
template = PromptTemplate(
    input_variables=["topic", "count"],
    template="推荐{count}本关于{topic}的图书："
)

# 现代：消息模板（推荐用于Chat Model）
from langchain_core.prompts import ChatPromptTemplate

chat_template = ChatPromptTemplate.from_messages([
    ("system", "你是{library_name}的图书推荐专家，擅长{domain}领域"),
    ("human", "请推荐{count}本关于{topic}的书"),
    ("ai", "我来为您精心挑选："),
    ("human", "要求：{requirements}")
])

2. 少样本学习（Few-shot Prompting）的技术实现

Few-shot通过**上下文学习（In-context Learning）**激活模型的模式匹配能力，无需微调：

from langchain_core.prompts import FewShotChatMessagePromptTemplate, ChatPromptTemplate

# 结构化示例（图书推荐场景）
examples = [
    {
        "input": "Python初学者", 
        "output": """1. 《Python编程：从入门到实践》- Eric Matthes (人民邮电出版社)
           理由：项目驱动，涵盖基础语法到Web开发
           馆藏位置：TP311.56/M3-2"""
    },
    {
        "input": "机器学习理论", 
        "output": """1. 《统计学习方法》- 李航 (清华大学出版社)
           理由：系统讲解算法原理与数学推导
           馆藏位置：TP181/L3"""
    }
]

# 示例格式化器
example_prompt = ChatPromptTemplate.from_messages([
    ("human", "{input}"),
    ("ai", "{output}")
])

few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_prompt=example_prompt,
    examples=examples,
)

# 组合完整提示
final_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的图书馆推荐系统。严格遵循以下输出格式：书名-作者-出版社-推荐理由-馆藏位置"),
    few_shot_prompt,  # 动态注入示例
    ("human", "{user_query}")
])

# 工作原理：模型从示例中学习模式，而非记忆参数更新

3. 动态示例选择（Example Selector）

当示例库庞大时，动态选择最相关的示例：

from langchain_core.example_selectors import SemanticSimilarityExampleSelector
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

# 示例库
examples = [
    {"input": "Python入门", "output": "..."},
    {"input": "Java高级特性", "output": "..."},
    {"input": "Python数据分析", "output": "..."},
    # ... 数百个示例
]

# 基于语义相似度选择top-k示例
example_selector = SemanticSimilarityExampleSelector.from_examples(
    examples,
    OpenAIEmbeddings(),
    Chroma,
    k=3  # 只选择最相关的3个示例
)

# 输入"Python机器学习"时，会自动选择Python相关的示例，而非Java的

Prompt Hub与版本控制：

from langchain import hub

# 拉取社区优化的提示模板（版本化）
prompt = hub.pull("rlm/rag-prompt")  # RAG标准提示
prompt = hub.pull("rlm/text-to-sql")  # 文本转SQL

# 推送自定义模板（团队协作）
hub.push("my-org/library-recommendation", final_prompt)

2.2.3 LCEL：声明式流程编排语言

LCEL的底层架构：

LCEL（LangChain Expression Language）基于Runnable协议 ，所有组件实现统一的invoke/stream/batch接口：
Runnable协议
Runnable Interface

标准契约
invoke

单输入调用
batch

批量并行
stream

流式输出
astream_events

事件追踪
具体实现
PromptTemplate
ChatModel
Retriever
OutputParser
自定义函数

管道操作符详解：

from langchain_core.runnables import RunnablePassthrough, RunnableParallel, RunnableLambda
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# 1. 基础链式（| 操作符）
# 数学含义：函数复合 (f ∘ g)(x) = f(g(x))
prompt = ChatPromptTemplate.from_template("解释图书馆中的{concept}概念")
model = ChatOpenAI()
parser = StrOutputParser()

chain = prompt | model | parser
# 等价于：parser.invoke(model.invoke(prompt.invoke({"concept": "索书号"})))

# 2. 数据流转换（RunnablePassthrough）
# 用途：保持原始输入同时传递给下游
chain = (
    {"concept": RunnablePassthrough()}  # 直接透传输入
    | prompt
    | model
    | parser
)

# 3. 并行处理（RunnableParallel）
# 技术实现：自动识别独立分支，启用线程池并行执行
retrieval_chain = RunnableParallel(
    {
        "context": lambda x: "索书号是图书馆赋予每本图书的唯一标识",  # 模拟检索
        "question": RunnablePassthrough()
    }
) | prompt | model | parser

# 执行时：context和question分支并行计算，减少总延迟

# 4. 动态路由（RunnableBranch）
from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (lambda x: "查询" in x["query"], retrieval_chain),  # 条件1
    (lambda x: "借阅" in x["query"], circulation_chain),  # 条件2
    general_chain  # 默认分支
)

LCEL的自动优化机制：

# LCEL在运行时自动应用以下优化：

# 优化1：并行化（Parallelization）
# 当RunnableParallel中的分支无依赖时，自动启用多线程
parallel = RunnableParallel(
    a=chain1,  # 独立执行
    b=chain2,  # 独立执行
    c=chain3   # 独立执行
)
# 总延迟 = max(延迟a, 延迟b, 延迟c)，而非三者之和

# 优化2：批处理（Batching）
inputs = [{"query": "q1"}, {"query": "q2"}, {"query": "q3"}]
results = chain.batch(inputs, max_concurrency=5)  # 自动并发控制

# 优化3：流式传输（Streaming）
for token in chain.stream({"query": "图书馆是什么"}):
    print(token, end="", flush=True)  # 实时输出，减少首token延迟（TTFT）

# 优化4：追踪与回调（Tracing）
# 自动注入LangSmith追踪，记录每个步骤的输入输出、延迟、token数

---

2.3 运行本地模型：私有化部署的完整方案

2.3.1 Ollama架构深度解析

Ollama是面向开发者的本地LLM容器平台，其架构设计借鉴了Docker的理念：
Ollama架构
CLI/API层

Go语言
Model Hub

模型仓库
GGUF格式模型

量化压缩
llama.cpp运行时

C/C++后端
CPU推理

OpenBLAS/AVX
GPU加速

CUDA/Metal
REST API

OpenAI兼容
Modelfile

配置定义
系统提示
参数设置

temperature/top_p
模板格式

chatml/llama2

量化技术对比：

量化类型	位数	精度损失	显存需求 (Llama 3 70B)	适用场景
FP16	16位	0%	140GB	研究/高精度需求
Q8_0	8位	<1%	70GB	生产级本地部署
Q4_K_M	4位	2-3%	40GB	消费级GPU（推荐）
Q3_K_S	3位	5-7%	30GB	极限压缩（边缘设备）

Ollama最佳实践：

from langchain_ollama import ChatOllama

# 高级配置（生产环境）
local_llm = ChatOllama(
    model="llama3.1:70b",  # 明确指定版本
    base_url="http://localhost:11434",
    
    # 推理参数
    temperature=0.7,       # 控制随机性
    num_ctx=8192,         # 上下文长度（默认2048）
    num_predict=512,      # 最大生成token数
    top_p=0.9,           # 核采样
    repeat_penalty=1.1,   # 重复惩罚（防止循环输出）
    
    # 性能参数
    num_gpu=50,          # 加载到GPU的层数（自动：-1）
    num_thread=8,        # CPU推理线程数
    
    # 系统提示（可在Modelfile中预设）
    system="你是图书馆智能助手"
)

# 验证模型加载
response = local_llm.invoke("你好")
print(response.content)

2.3.2 Hugging Face Transformers深度集成

Transformers Pipeline架构：

from langchain_huggingface import HuggingFacePipeline, ChatHuggingFace
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch

# 方案1：使用预配置Pipeline（快速启动）
model_id = "meta-llama/Meta-Llama-3-8B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)

# 加载配置详解
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,      # 混合精度，节省显存
    device_map="auto",               # 自动分配层到GPU/CPU
    load_in_8bit=True,               # 8位量化（bitsandbytes）
    # load_in_4bit=True,             # 4位量化（更激进）
    trust_remote_code=True,          # 允许执行模型自定义代码
)

# 创建pipeline
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=256,
    do_sample=True,
    temperature=0.7,
    top_p=0.95,
    repetition_penalty=1.15,
    return_full_text=False,          # 只返回新生成内容
)

hf_llm = HuggingFacePipeline(pipeline=pipe)

# 方案2：使用ChatHuggingFace（推荐，兼容OpenAI接口）
chat_model = ChatHuggingFace(llm=hf_llm)

本地部署方案对比：
本地部署技术栈
模型来源
Hugging Face

Transformers
Ollama

GGUF格式
vLLM

生产级推理
灵活性高

研究首选
易用性好

开发首选
吞吐量大

生产首选
显存需求高

配置复杂
生态丰富

一键运行
多卡并行

PagedAttention

⚠️ 关键纠正与优化：

1. 内存管理误区

   • 错误：load_in_8bit适合所有场景
   • 纠正：8bit量化（LLM.int8()）对矩阵乘法进行分块量化，小于6B的模型量化反而可能更慢（量化开销 > 收益）
   • 优化：小模型（<7B）用FP16，大模型（>13B）用4bit（NF4格式）

2. 上下文长度限制解决方案

   # 问题：Llama 3本地通常只有8K上下文（官方支持128K需特定配置）
   
   # 方案1：滑动窗口（Sliding Window）
   def sliding_window_process(long_text, window_size=4096, step=2048):
       """分段处理长文档"""
       chunks = []
       for i in range(0, len(long_text), step):
           chunk = long_text[i:i+window_size]
           chunks.append(chunk)
       # 分别处理每个chunk，再聚合结果
       return chunks
   
   # 方案2：RAG检索（推荐）
   # 将长文档切分存入向量库，只检索相关片段输入模型
   
   # 方案3：使用长上下文专用模型
   # 如：Yi-6B-200K, Qwen2-7B-Instruct（支持128K）

3. 推理速度优化

   # 批处理（Batching）减少 overhead
   from langchain_core.prompts import ChatPromptTemplate
   
   template = ChatPromptTemplate.from_template("总结以下内容：{text}")
   chain = template | local_llm | StrOutputParser()
   
   texts = ["文本1...", "文本2...", "文本3..."]
   
   # 方法1：LangChain自动批处理（推荐）
   results = chain.batch([{"text": t} for t in texts], max_concurrency=3)
   
   # 方法2：手动批处理（更底层控制）
   inputs = template.batch([{"text": t} for t in texts])
   outputs = local_llm.batch(inputs)

2.3.3 本地模型的生产级部署

架构选型决策树：
低并发

个人/小团队
高并发

企业级
本地部署需求
并发要求?
Ollama

快速部署
vLLM/TGI
单卡推理

简单API
vLLM

PagedAttention

Continuous Batching
Text Generation Inference

HuggingFace出品
多卡张量并行

高吞吐
多模型服务

企业特性
Docker Compose

单节点
Kubernetes

集群编排

---

2.4 多模态AI应用：超越文本的智能服务

现代图书馆AI需要处理图像、音频、视频等多模态内容，这要求理解多模态模型的架构原理。

2.4.1 文本到图像生成：视觉内容创作

技术架构：
语义条件
文本提示

Prompt
文本编码器

CLIP Text Encoder
随机噪声

Latent Noise
扩散模型

Diffusion Model
latent空间

去噪迭代
VAE解码器

生成像素
图像输出

PNG/JPG

LangChain集成方案：

from langchain_openai import DallEAPIWrapper
from langchain_core.tools import tool

# DALL-E 3（高质量，高成本）
dalle = DallEAPIWrapper(
    model="dall-e-3",
    size="1024x1024",       # 支持：1024x1024, 1792x1024, 1024x1792
    quality="standard",     # 或 "hd"（细节增强，成本2x）
    n=1                     # 生成数量（DALL-E 3只支持1）
)

# 生成图像
image_url = dalle.run("""
    为图书馆'科幻文学月'活动设计海报。
    要求：未来主义风格，包含漂浮的书籍、星空背景、银色和蓝色色调，
    底部留白用于添加活动信息，专业设计感
""")

# 保存到本地（用于图书馆CMS系统）
import requests
from pathlib import Path

def save_image(url: str, path: str):
    response = requests.get(url)
    Path(path).write_bytes(response.content)
    return path

save_image(image_url, "posters/scifi_month_2024.png")

本地替代方案（Stable Diffusion）：

from diffusers import StableDiffusionPipeline
import torch

# 本地部署（需要8GB+ VRAM）
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id, 
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 生成（支持中文需额外配置，或使用 translated prompt）
prompt = "library poster, science fiction theme, floating books, starry background, professional design, high quality"
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("local_poster.png")

2.4.2 图像理解：视觉内容编目与检索

多模态LLM架构（以GPT-4V为例）：

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# GPT-4o / Claude 3 支持视觉理解
vision_llm = ChatOpenAI(model="gpt-4o")  # 或 "claude-3-opus-20240229"

# 构造多模态消息
message = HumanMessage(
    content=[
        {
            "type": "text", 
            "text": """分析这张图书馆老照片，提供以下信息：
            1. 场景描述（建筑特征、室内布局）
            2. 年代推测（基于服饰、家具、图书装帧）
            3. 历史价值评估
            4. 建议的元数据标签（用于数字档案系统）
            """
        },
        {
            "type": "image_url",
            "image_url": {
                "url": "https://library-archive.edu/photos/1950s_reading_room.jpg",
                # 支持base64编码的本地图片："data:image/jpeg;base64,/9j/4AAQ..."
            }
        }
    ]
)

response = vision_llm.invoke([message])
print(response.content)

完整的多模态编目工作流：
💾 向量化与应用
🧠 智能分析与理解
📥 数据接入与预处理
批量上传

古籍 / 照片 / 手稿
图像预处理

去噪 / 增强 / 几何校正
OCR 引擎

PaddleOCR / EasyOCR
视觉理解模型 (VLM)

GPT-4V / Claude 3 / Qwen-VL
生成详细描述

结构化元数据提取
文本提取

标题 / 作者 / 年代
数据融合

描述 + OCR 结果合并
Embedding 向量化

多模态嵌入模型
向量数据库

Milvus / Pinecone
语义检索终端

'找 1950 年代的阅览室照片'

技术选型对比：

模型	优势	成本	本地部署	中文支持
GPT-4V	最准确的描述能力	$0.005-0.015/图像	❌	良好
Claude 3	长上下文（200K），细节丰富	$0.003-0.015/图像	❌	良好
Qwen-VL	中文优化，开源	免费（自托管）	✅	优秀
LLaVA	完全开源，可定制	免费（自托管）	✅	需微调

⚠️ 注意 ：早期多模态方案需要分别使用CLIP编码图像和文本，再计算相似度 。现代多模态LLM（GPT-4V/Claude 3）是端到端训练的，直接将图像像素输入Transformer，无需单独的Embedding步骤。

批量处理与成本控制：

from langchain_core.runnables import RunnableLambda
import base64

def encode_image(image_path):
    """将本地图片转为base64"""
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode()

# 批量编目函数
def catalog_images(image_paths: list) -> list:
    results = []
    for path in image_paths:
        base64_image = encode_image(path)
        
        message = HumanMessage(
            content=[
                {"type": "text", "text": "为图书馆档案生成元数据"},
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
            ]
        )
        
        response = vision_llm.invoke([message])
        results.append({
            "file": path,
            "metadata": response.content,
            "timestamp": datetime.now().isoformat()
        })
    return results

# 使用批处理降低成本（并行API调用）
catalog_chain = RunnableLambda(catalog_images)
metadata_list = catalog_chain.invoke(["photo1.jpg", "photo2.jpg", "photo3.jpg"])

---

本章小结

关键工程认知：

1. 环境隔离是生产基础：必须使用venv/conda，避免依赖地狱
2. 接口选择决定架构：始终使用ChatModel而非Legacy LLM接口
3. LCEL是工程化核心：掌握Runnable协议，利用自动优化（并行、批处理、流式）
4. 本地部署需权衡：Ollama适合开发，vLLM适合生产，量化技术平衡精度与成本
5. 多模态是趋势：现代图书馆AI必须处理视觉内容，GPT-4V/Qwen-VL提供开箱即用的能力

---