langchain调用大模型方式和模板角色解析

原创已于 2025-05-10 16:56:30 修改 · 1k 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#langchain #语言模型 #人工智能

于 2025-05-10 16:44:22 首次发布

langchain是啥？

我们可以理解大模型是数据库，langchain是jdbc驱动。我们只需要编写sql然后调用 jdbc接口就可以了。
LangChain 是一个用于开发由大型语言模型 (LLMs) 驱动的应用程序的框架。

案例讲解


from langchain_core.prompts import PromptTemplate, ChatPromptTemplate
from langchain_ollama import ChatOllama

template = "桌上有{number}个苹果，四个桃子和3本书共有几个水果?"
prompt = PromptTemplate.from_template(template)

# 创建模型实例
# llm = ChatOpenAI(temperature=0)
# 可以通过指令 ollama show qwen2.5:7b --path 查看目录  ollama list
llm = ChatOllama(model="qwen2.5:1.5b", temperature=0.3)
# 创建链  | 符号是 channel 管道意思。
chain = prompt | llm

# 调用链
result = chain.invoke({"number": 5})
print(result)

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是世界级的技术专家"),
    ("user", "{input}")
])
chain = prompt | llm
result = chain.invoke({"input": "帮我写一个关于ai的100字左右的技术文章"})
print(result.content)
print(result.additional_kwargs)  # 表示调用时传入的附加参数，本例中 {'refusal': None} 表示未设置拒绝信息或其他附加参数。
# token_usage：记录本次调用使用的 token 数量：completion_tokens：模型生成回复使用了 176 个 token。
# total_tokens：总共使用了 217 个 token（输入与输出相加）。
print(result.response_metadata)
# input_tokens：输入的 token 数量;output_tokens：输出的 token 数量

总结上面步骤：然后一个个分析。

构建模板PromptTemplate
调用大模型Model
创建链 chain = prompt | llm
请求大模型回答 chain.invoke()

怎么调大模型

#这是调用 ollama模型
llm = ChatOllama(model="qwen2.5:1.5b", temperature=0.3)

如果调用openAI的模型?

pip install -qU langchain-openai
model = ChatOpenAI(model="gpt-4")

调用 Hugging Face 模型安装 transformers

# 加载模型和分词器
model_name = "bert-base-chinese"  # 替换为任何HF模型
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 创建 pipeline
hf_pipeline = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_length=100
)

# 转换为 LangChain 可调用的对象
llm = HuggingFacePipeline(pipeline=hf_pipeline)

# 调用 这个是没有调用模板的方式 复杂业务时准确性比较差
response = llm.invoke("解释一下量子计算")
print(response)

# 4. 定义Prompt模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是世界级的技术专家，用简洁易懂的语言回答技术问题。"),
    ("user", "{input}")
])

# 5. 创建处理链
chain = prompt | llm | StrOutputParser()
# 调用
response = chain.invoke({"input": "解释一下量子计算"})

还可以是google模型

pip install google-generativeai langchain-google-genai
# 设置 Google API 密钥
os.environ["GOOGLE_API_KEY"] = "your_google_api_key"

# 初始化 Gemini 模型
llm = ChatGoogleGenerativeAI(model="gemini-pro")

# 调用模型
response = llm.invoke("用Python写一个快速排序算法")

总结：我一般使用ollama和HuggingFace 模型其他很少用。
LangChain 官方并未直接集成 ModelScope 模型
ModelScope 的许多模型与 Hugging Face 架构兼容，可通过 transformers 库加载后接入 LangChain，查考下面案例：

rom modelscope import AutoModelForCausalLM, AutoTokenizer
from langchain_community.llms import HuggingFacePipeline

# 加载 ModelScope 模型（示例：达摩院开源的 Qwen 系列）
model_id = "qwen/Qwen-1_8B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True)

# 创建 Hugging Face pipeline
from transformers import pipeline
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_length=100
)

# 接入 LangChain
llm = HuggingFacePipeline(pipeline=pipe)

# 调用
response = llm.invoke("如何学习深度学习？")

模板ChatPromptTemplate 和角色的作用

ChatPromptTemplate 定义一个对话式提示模板（Prompt Template），用于结构化地生成 AI 对话的输入。
具体作用：

system 消息：设定 AI 的角色和背景（如“你是世界级的技术专家”），引导模型的行为风格。
user 消息：提供用户输入（如 {input} 是一个占位符，运行时会被实际用户问题替换）。
最终生成的 Prompt 会像这样传递给模型：

[
    {"role": "system", "content": "你是世界级的技术专家"},
    {"role": "user", "content": "如何优化Python代码性能？"}
]

为什么需要 system 和 user 两个角色？
(1) system 角色的用途

控制模型行为：通过系统消息设定模型的角色、语气或任务规则（例如“你是一个严谨的科学家”）。
提高回复一致性：避免模型在对话中偏离预设方向（比如突然切换成闲聊模式）。
适用于多轮对话：在长期会话中保持上下文连贯性。

(2) user 角色的用途

明确用户输入：区分哪些内容是用户的问题或指令（例如 {input} 会被替换为实际提问）。
支持多角色交互：如果需要模拟多用户对话（如客服系统），可以扩展更多角色（如 assistant）

何时必须用 system 消息？

角色扮演类应用：如客服、教师、游戏 NPC。
任务约束：例如要求模型“用列表形式输出”或“仅回答技术问题”。
安全控制：通过 system 限制模型不回答敏感话题。

总结:
这样分角色：能精细控制模型行为，适合复杂任务。

案例：如果想添加模型的历史回复（多轮对话），可以加入 assistant 角色

from langchain_core.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是技术专家，用简洁语言回答"),
    ("user", "什么是线程安全？"),
    ("assistant", "线程安全指多线程下代码行为正确。"),
    ("user", "{input}")  # 新问题
])

llm.invoke() 是用于调用语言模型（LLM）的核心接口

作用：同步调用语言模型生成文本。

def invoke(
    self,
    input: Union[str, List[str], PromptValue],  # 输入内容
    config: Optional[RunnableConfig] = None,    # 运行时配置
    **kwargs: Any                              # 模型特定参数
) -> Union[str, List[str]]:                    # 返回文本或列表

config

{
    "tags": ["test"],          # 打标签（用于监控）
    "metadata": {"key": "value"},  # 附加元数据
    "callbacks": my_handler    # 回调函数（处理流式输出等）
}

示例：llm.invoke(“Hello”, config={“tags”: [“demo”]})

高级参数控制

response = llm.invoke(
    "生成Python代码示例",
    temperature=0.5,
    max_length=100,
    config={
        "tags": ["code-generation"],
        "metadata": {"user": "Alice"}
    }
)

总结：llm.invoke() 是 LangChain 中最直接的模型调用方式，平衡了灵活性和易用性。对于复杂场景（如流式、批量）。

流式处理（Streaming）

适用场景：逐词/逐块输出结果，适合聊天应用或长文本生成。

# 同步流式调用
for chunk in llm.stream("解释量子力学："):
    print(chunk, end="", flush=True)  # 逐词打印

异步流式 astream()

async def async_stream():
    async for chunk in llm.astream("写一个Python爬虫代码："):
        print(chunk, end="", flush=True)

asyncio.run(async_stream())

同步批量 batch()

inputs = ["什么是机器学习？", "深度学习的应用场景有哪些？"]
responses = llm.batch(inputs)  # 返回List[str]

for q, ans in zip(inputs, responses):
    print(f"Q: {q}\nA: {ans}\n")