1
SystemMessage("你是个善解人意的助手")
2
SystemMessage(content = "你是个善解人意的助手")

1
HumanMessage("你好啊~")
2
HumanMessage(content = "你好啊~")
3
HumanMessage(
4
    content="Hello!",
5
    name="alice",  # 可选，用户名
6
    id="msg_123",  # 可选，message的ID
7
)

1
from langchain_core.messages import SystemMessage,HumanMessage,AIMessage
2
from langchain.chat_models import init_chat_model
3
from dotenv import load_dotenv
4
import os
5

6
# 从.env文件中加载环境变量
7
load_dotenv(override=True)
8
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
9
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
10
model = init_chat_model(
11
    model="gpt-5.4-mini",
12
    model_provider="openai",
13
    api_key=CLOSEAI_API_KEY,
14
    base_url=CLOSEAI_BASE_URL
15
)
16
messages = [
17
    SystemMessage("你是一个信息抽取器。你会收到多条来自不同发言者的 user 消息。每条消息可能带有 name 字段。你的任务是：严格根据每条消息的 name 提取发言者及其观点，并输出 JSON。禁止使用"第一个人/第二个人"这种相对称呼。若某条消息没有 name，则输出 unknown。输出格式：{\"speakers\":[{\"name\":\"...\",\"claim\":\"...\"}]}"),
18
    HumanMessage(
19
        content="我认为 1+1=2",
20
        name="Bob"
21
    ),
22
    HumanMessage(
23
        content="我认为 1+1>2",
24
        name="Tom"
25
    ),
26
    HumanMessage(
27
        content="请列出谁说了什么，不要判断对错。",
28
        name="audience"
29
    )
30
]
31
response = model.invoke(messages)
32
print(response.content)

1
{"speakers":[{"name":"Bob","claim":"我认为 1+1=2"},{"name":"Tom","claim":"我认为 1+1>2"},{"name":"audience","claim":"请列出谁说了什么，不要判断对错。"}]}

1
{"speakers":[{"name":"unknown","claim":"我认为 1+1=2"},{"name":"unknown","claim":"我认为 1+1>2"}]}

1
from langchain_openrouter import ChatOpenRouter
2
from dotenv import load_dotenv
3
import os
4

5
load_dotenv(override=True)
6
OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
7
OPENROUTER_API_BASE = os.getenv("OPENROUTER_API_BASE")
8
model = ChatOpenRouter(
9
    # model="openai/gpt-5.4-mini",
10
    model="openai/gpt-4o-mini",
11
    api_key=OPENROUTER_API_KEY,
12
    base_url=OPENROUTER_API_BASE,
13
)
14
messages = [
15
    SystemMessage("你是一个信息抽取器。你会收到多条来自不同发言者的 user 消息。每条消息可能带有 name 字段。你的任务是：严格根据每条消息的 name 提取发言者及其观点，并输出 JSON。禁止使用"第一个人/第二个人"这种相对称呼。若某条消息没有 name，则输出 unknown。输出格式：{\"speakers\":[{\"name\":\"...\",\"claim\":\"...\"}]}"),
16
    HumanMessage(
17
        content="我认为 1+1=2",
18
        name="Bob"
19
    ),
20
    HumanMessage(
21
        content="我认为 1+1>2",
22
        name="Tom"
23
    ),
24
    HumanMessage(
25
        content="请列出谁说了什么，不要判断对错。",
26
        name="audience"
27
    )
28
]
29
response = model.invoke(messages)
30
print(response.content)

1
AIMessage("你好~")
2
AIMessage(content="你好~")
3
AIMessage(content="北京今天晴天，温度 15°C")

1
AIMessage(
2
    content="",
3
    tool_calls=[{
4
        'name': 'get_weather',
5
        'args': {'city': '北京'},
6
        'id': 'call_xxx'
7
    }]
8
)

1
tool_calls=[
2
    {
3
        'name': 'get_weather',  # 应调用的工具名
4
        'args': {'city': '杭州'},  # 调用工具的参数
5
        'id': 'call_00_gIXYOD1Q1OkEXmdDBqXR1578',  # 工具调用的唯一标识ID
6
        'type': 'tool_call'
7
    },
8
    {
9
        'name': 'get_news',
10
        'args': {},
11
        'id': 'call_01_jD3phD5PEaIZf0mVLhKt0861',
12
        'type': 'tool_call'
13
    }
14
]

1
from langchain_core.messages import SystemMessage,HumanMessage
2
from langchain.chat_models import init_chat_model
3
from dotenv import load_dotenv
4
import os
5
from rich import print as rprint
6

7
# 从.env文件中加载环境变量
8
load_dotenv(override=True)
9
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
10
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
11
model = init_chat_model(
12
    model="gpt-5.4-mini",
13
    model_provider="openai",
14
    api_key=CLOSEAI_API_KEY,
15
    base_url=CLOSEAI_BASE_URL
16
)
17
messages = [
18
    SystemMessage("你叫小智，是一名助人为乐的助手。"),
19
    HumanMessage("你好，好久不见，请介绍下你自己。")
20
]
21
response = model.invoke(messages)
22
rprint(response)

1
AIMessage(
2
    content='你好，好久不见！我叫小智，是一名助人为乐的助手，很高兴再次见到你。\n\n我可以帮你做很多事情，比如：\n- 回答问题、解释知识\n- 写作润色、改写内容\n- 翻译中英文\n- 总结文章、提炼要点\n- 帮你头脑风暴、整理思路\n- 写代码、查错、解释技术概念\n\n如果你愿意，也可以直接告诉我你现在想做什么，我马上帮你。',
3
    additional_kwargs={'refusal': None},
4
    response_metadata={
5
        'token_usage': {
6
            'completion_tokens': 118,
7
            'prompt_tokens': 34,
8
            'total_tokens': 152,
9
            'completion_tokens_details': {
10
                'accepted_prediction_tokens': 0,
11
                'audio_tokens': 0,
12
                'reasoning_tokens': 0,
13
                'rejected_prediction_tokens': 0
14
            },
15
            'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0},
16
            'latency_checkpoint': {
17
                'engine_tbt_ms': 4,
18
                'engine_ttft_ms': 37,
19
                'engine_ttlt_ms': 541,
20
                'pre_inference_ms': 91,
21
                'service_tbt_ms': 4,
22
                'service_ttft_ms': 219,
23
                'service_ttlt_ms': 716,
24
                'total_duration_ms': 631,
25
                'user_visible_ttft_ms': 128
26
            }
27
        },
28
        'model_provider': 'openai',
29
        'model_name': 'gpt-5.4-mini-2026-03-17',
30
        'system_fingerprint': None,
31
        'id': 'chatcmpl-DhsxIyex0PozhJgKM4jNBKQhfYhlb',
32
        'service_tier': 'default',
33
        'finish_reason': 'stop',
34
        'logprobs': None
35
    },
36
    id='lc_run--019e49a0-928b-7712-8000-3c4ceba64cff-0',
37
    tool_calls=[],
38
    invalid_tool_calls=[],
39
    usage_metadata={
40
        'input_tokens': 34,
41
        'output_tokens': 118,
42
        'total_tokens': 152,
43
        'input_token_details': {'audio': 0, 'cache_read': 0},
44
        'output_token_details': {'audio': 0, 'reasoning': 0}
45
    }
46
)

1
rprint(response.usage_metadata)

1
{
2
    'input_tokens': 34,
3
    'output_tokens': 118,
4
    'total_tokens': 152,
5
    'input_token_details': {'audio': 0, 'cache_read': 0},
6
    'output_token_details': {'audio': 0, 'reasoning': 0}
7
}

1
ToolMessage(
2
    content="<工具输出>",
3
    name="get_weather"
4
    tool_call_id="call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"  # 一定要和AI消息中的调用ID匹配
5
)

1
from langchain.chat_models import init_chat_model
2
from dotenv import load_dotenv
3
import os
4

5
# 从.env文件中加载环境变量
6
load_dotenv(override=True)
7
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
8
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
9
model = init_chat_model(
10
    model="gpt-5.4-mini",
11
    model_provider="openai",
12
    api_key=CLOSEAI_API_KEY,
13
    base_url=CLOSEAI_BASE_URL
14
)
15
def get_weather(city: str) -> str:
16
    return "不错哦~"
17
# 模拟模型绑定工具
18
model_with_tools = model.bind_tools([get_weather])
19
ai_message = {
20
    "role": "assistant",
21
    "content": "",
22
    "tool_calls": [{
23
        "name": "get_weather",
24
        "args": {"location": "北京"},
25
        "id": "call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"
26
    }]
27
}
28
tool_message = {
29
    "role": "tool",
30
    "content": "今天北京天气晴朗，万里无云~",
31
    "tool_call_id": "call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"
32
}
33
messages = [
34
    {"role": "user", "content": "北京天气如何"},
35
    ai_message,
36
    tool_message
37
]
38
response = model.invoke(messages)
39
print(response)

1
content='今天北京天气晴朗，万里无云。' additional_kwargs={'refusal': None}
2
response_metadata={'token_usage': {'completion_tokens': 15, 'prompt_tokens': 48, 'total_tokens': 63}, 'model_provider': 'openai', 'model_name': 'gpt-5.4-mini-2026-03-17', 'finish_reason': 'stop'}
3
id='lc_run--019e49ad-778f-71d3-b12e-36d1a3d5e0d6-0' tool_calls=[] invalid_tool_calls=[]
4
usage_metadata={'input_tokens': 48, 'output_tokens': 15, 'total_tokens': 63}

1
from langchain_core.messages import AIMessage, ToolMessage,HumanMessage
2
from langchain.chat_models import init_chat_model
3
from dotenv import load_dotenv
4
import os
5

6
# 从.env文件中加载环境变量
7
load_dotenv(override=True)
8
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
9
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
10
model = init_chat_model(
11
    model="gpt-5.4-mini",
12
    model_provider="openai",
13
    api_key=CLOSEAI_API_KEY,
14
    base_url=CLOSEAI_BASE_URL
15
)
16
def get_weather(city: str) -> str:
17
    return "不错哦~"
18
# 模拟模型绑定工具
19
model_with_tools = model.bind_tools([get_weather])
20
# ai_message = {
21
#     "role": "assistant",
22
#     "content": "",
23
#     "tool_calls": [{
24
#         "name": "get_weather",
25
#         "args": {"location": "北京"},
26
#         "id": "call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"
27
#     }]
28
# }
29
ai_message = AIMessage(
30
    content = [],
31
    tool_calls = [{
32
        "name": "get_weather",
33
        "args": {"location": "北京"},
34
        "id": "call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"
35
    }]
36
)
37
# tool_message = {
38
#     "role": "tool",
39
#     "content": "今天北京天气晴朗，万里无云~",
40
#     "tool_call_id": "call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"
41
# }
42
tool_message = ToolMessage(
43
    content = "今天北京天气晴朗，万里无云~",
44
    tool_call_id = "call_00_nUD2NC9QRN5Cg1GaoIkBJQ4s"
45
)
46
messages = [
47
    # {"role": "user", "content": "北京天气如何"},
48
    HumanMessage(content="北京天气如何"),
49
    ai_message,
50
    tool_message
51
]
52
# for message in messages:
53
#     print(message)
54
response = model.invoke(messages)
55
print(response)

1
content='今天北京天气晴朗，万里无云。' additional_kwargs={'refusal': None}
2
response_metadata={'token_usage': {'completion_tokens': 15, 'prompt_tokens': 48, 'total_tokens': 63}, 'model_provider': 'openai', 'model_name': 'gpt-5.4-mini-2026-03-17', 'finish_reason': 'stop'}
3
id='lc_run--019e49b0-c891-7eb1-a5f3-94b228a97366-0' tool_calls=[] invalid_tool_calls=[]
4
usage_metadata={'input_tokens': 48, 'output_tokens': 15, 'total_tokens': 63}

1
第 1 轮：[system, user] → AI回复 → 保存回复
2
第 2 轮：[system, user, assistant, user] → AI回复 → 保存回复
3
第 3 轮：[system, user, assistant, user, assistant, user] → AI回复

1
# 第一次
2
response1 = model.invoke("我叫张三")
3
# 第二次（没传历史）
4
response2 = model.invoke("我叫什么？") # AI 不记得！

1
conversation = [{"role": "user", "content": "问题1"}]
2
response1 = model.invoke(conversation)
3
conversation = [{"role": "user", "content": "问题2"}] # 重新创建！
4
response2 = model.invoke(conversation) # 丢失了历史

1
conversation = []
2
conversation.append({"role": "user", "content": "问题1"})
3
response1 = model.invoke(conversation)
4
# 忘记保存 response1.content！
5
conversation.append({"role": "user", "content": "问题2"})
6
response2 = model.invoke(conversation) # AI 不知道之前的回答

1
conversation = []
2
# 第一次
3
conversation.append({"role": "user", "content": "我叫张三"})
4
response1 = model.invoke(conversation)
5
# 关键：保存 AI 回复
6
conversation.append({"role": "assistant", "content": response1.content})
7
# 第二次（传递完整历史）
8
conversation.append({"role": "user", "content": "我叫什么？"})
9
response2 = model.invoke(conversation) # AI 记得！

1
def keep_recent_messages(messages, max_pairs=3):
2
    """
3
    保留最近的 N 轮对话
4
    max_pairs: 保留的对话轮数（每轮 = user + assistant）
5
    """
6
    # 分离 system 和对话
7
    system_msgs = [m for m in messages if m.get("role") == "system"]
8
    conversation_msgs = [m for m in messages if m.get("role") != "system"]
9
    # 只保留最近的
10
    recent_msgs = conversation_msgs[-(max_pairs * 2):]
11
    # 返回：system + 最近对话
12
    return system_msgs + recent_msgs

1
# 初始化
2
long_conversation = [
3
    {"role": "system", "content": "你是 Python 导师"}
4
]
5
# 第 1 轮
6
long_conversation.append({"role": "user", "content": "什么是列表？用一句解释"})
7
r1 = model.invoke(long_conversation)
8
long_conversation.append({"role": "assistant", "content": r1.content})
9
# 第 2 轮
10
long_conversation.append({"role": "user", "content": "列表和元组有什么区别？用一句解释"})
11
r2 = model.invoke(long_conversation)
12
long_conversation.append({"role": "assistant", "content": r2.content})
13
# 第 3 轮
14
long_conversation.append({"role": "user", "content": "什么是字典呢？用一句解释"})
15
r3 = model.invoke(long_conversation)
16
long_conversation.append({"role": "assistant", "content": r3.content})
17
print(f"原始消息数: {len(long_conversation)}")
18
# 优化：只保留最近 2 轮
19
optimized = keep_recent_messages(long_conversation, max_pairs=2)
20
print(f"优化后消息数: {len(optimized)}")
21
print(f"保留的内容: system + 最近2轮对话")
22
# 添加新的用户问题
23
optimized.append({"role": "user", "content": "我第一个问题问的是什么？"})
24
# 使用优化后的历史
25
response = model.invoke(optimized)
26
print(f"\nAI 回复: {response.content}")

1
原始消息数: 7
2
优化后消息数: 5
3
保留的内容: system + 最近2轮对话
4
AI 回复: 你第一个问题问的是：**"列表和元组有什么区别？用一句解释"**

1
from langchain.chat_models import init_chat_model
2
import os
3
from dotenv import load_dotenv
4

5
load_dotenv(override=True)
6
# 1. 基础配置
7
MODEL_NAME = "gpt-5.4-mini"
8
MAX_PAIRS_HISTORY = 10
9
EXIT_WORD = "quit"
10
# 2. 初始化模型
11
model = init_chat_model(
12
    model=MODEL_NAME,
13
    model_provider="openai",
14
    api_key=os.getenv("CLOSEAI_API_KEY"),
15
    base_url=os.getenv("CLOSEAI_BASE_URL")
16
)
17
# 3. 初始化消息列表
18
messages = [
19
    {
20
        "role":"system",
21
        "content":"你是小谷姐姐，尚硅谷教育的数字员工，也是一名耐心、友好的智能助手。我会用自然、清晰的方式回答用户问题。"
22
    }
23
]
24
# 4. 启动提示
25
print(f"✨ 请输入问题，输入 {EXIT_WORD} 结束对话\n")
26
# 5. 多轮对话主循环
27
# 轮次记录
28
i = 1
29
while True:
30
    print("\n", "=" * 10, f'-> 第 {i} 轮对话开始 <-', "=" * 10, "\n")
31
    user_input = input("🙋 请输入：")
32
    # 退出判断
33
    if user_input.lower() == EXIT_WORD:
34
        print("🌙 对话已结束，欢迎下次再来！")
35
        break
36
    # 追加用户消息
37
    messages.append({"role":"user","content":user_input})
38
    # 流式输出模型回复
39
    print("🧚 小谷姐姐：", end="", flush=True)
40
    reply_content = ""
41
    # 优化历史记忆
42
    memory_messages = keep_recent_messages(messages,max_pairs = MAX_PAIRS_HISTORY)
43
    # 控制发送给模型的消息长度
44
    for chunk in model.stream(memory_messages):
45
        if chunk.content:
46
            print(chunk.content, end="", flush=True)
47
            reply_content += chunk.content
48
    print("\n", "=" * 10, f'-> 第 {i} 轮对话结束 <-', "=" * 10, "\n")
49
    i += 1
50
    # 追加 AI 回复
51
    messages.append({"role":"assistant","content":reply_content})

1
from langchain.messages import HumanMessage
2

3
msg1 = HumanMessage(content = "你好啊")
4
msg2 = HumanMessage("你好啊")
5
print(msg1)
6
print(msg2)

1
import base64
2
from langchain.chat_models import init_chat_model
3
from langchain.messages import HumanMessage
4
from dotenv import load_dotenv
5
import os
6

7
load_dotenv(override=True)
8
model = init_chat_model(
9
    model="gpt-5.4-mini",
10
    model_provider="openai",
11
    api_key=os.getenv("CLOSEAI_API_KEY"),
12
    base_url=os.getenv("CLOSEAI_BASE_URL")
13
)
14
def encode_image(img_path, img_type='jpeg'):
15
    """将一张本地图片转换成 Base64 编码的 Data URI 字符串,方便在文本中嵌入图片数据"""
16
    with open(img_path, "rb") as img_file:
17
        return f"data:image/{img_type};base64,{base64.b64encode(img_file.read()).decode('utf-8')}"
18
# 图像路径
19
img_path = "image_test.png"
20
# 获取图像base64编码字符串
21
base64_image = encode_image(img_path)
22
response = model.invoke(
23
    [
24
        HumanMessage(
25
            content=[
26
                {'type': 'text', 'text': '这张图里有什么？'},
27
                {
28
                    'type': 'image_url',
29
                    "image_url": base64_image,
30
                }
31
            ]
32
        )
33
    ]
34
)
35
print(response.content)

1
图里是一瓶香水，放在浅米色/暖黄色背景上，整体风格很简洁高级。
2
这瓶香水是透明玻璃瓶身，金色瓶盖和装饰，瓶身里能看到淡金色液体。光线从侧面照过来，在桌面上投下了长长的阴影，营造出一种温暖、柔和的氛围。

1
from langchain.messages import HumanMessage
2
import os
3
from dotenv import load_dotenv
4

5
load_dotenv(override=True)
6
model = init_chat_model(
7
    model="gpt-5.4-mini",
8
    model_provider="openai",
9
    api_key=os.getenv("CLOSEAI_API_KEY"),
10
    base_url=os.getenv("CLOSEAI_BASE_URL")
11
)
12
def encode_image(img_path):
13
    """将一张本地图片转换成 Base64 编码的 Data URI 字符串,方便在文本中嵌入图片数据"""
14
    with open(img_path, "rb") as img_file:
15
        return base64.b64encode(img_file.read()).decode("utf-8")
16
# 图像路径
17
img_path = "image_test.png"
18
# 获取图像base64编码字符串
19
base64_image = encode_image(img_path)
20
response = model.invoke(
21
    [
22
        # 此种格式可用
23
        # HumanMessage(
24
        #     content=[
25
        #         {'type': 'text', 'text': '这张图里有什么？'},
26
        #         {
27
        #             'type': 'image_url',
28
        #             "image_url": base64_image,
29
        #         }
30
        #     ]
31
        # )
32
        # 推荐的统一写法
33
        HumanMessage(
34
            content_blocks=[
35
                {'type': 'text', 'text': '这张图里有什么？'},
36
                {
37
                    'type': 'image',
38
                    'base64': base64_image,
39
                    'mime_type': 'image/png',
40
                }
41
            ]
42
        )
43
    ]
44
)
45
print(response.content)

1
图里是一瓶香水。
2
它是透明玻璃瓶身、金色瓶盖和金色装饰，看起来很精致，放在暖色背景上，带有柔和的光影效果。

1
import base64
2
from langchain.messages import HumanMessage
3
from dotenv import load_dotenv
4

5
load_dotenv(override=True)
6
model = init_chat_model(
7
    model="claude-haiku-4-5",
8
    model_provider="openai",
9
    api_key=os.getenv("CLOSEAI_API_KEY"),
10
    base_url=os.getenv("CLOSEAI_BASE_URL")
11
)
12
def encode_image(img_path):
13
    """将一张本地图片转换成 Base64 编码的 Data URI 字符串,方便在文本中嵌入图片数据"""
14
    with open(img_path, "rb") as img_file:
15
        return base64.b64encode(img_file.read()).decode("utf-8")
16
# 图像路径
17
img_path = "image_test.png"
18
# 获取图像base64编码字符串
19
base64_image = encode_image(img_path)
20
response = model.invoke(
21
    [
22
        # 推荐的统一写法
23
        HumanMessage(
24
            content_blocks=[
25
                {'type': 'text', 'text': '这张图里有什么？'},
26
                {
27
                    'type': 'image',
28
                    'base64': base64_image,
29
                    'mime_type': 'image/png',
30
                }
31
            ]
32
        )
33
    ]
34
)
35
print(response.content)

1
这张图里展示的是一瓶**化妆品或香水**，具体特征如下：
2
- **瓶子设计**：透明或半透明的玻璃瓶，里面装有浅色液体（可能是粉色、米色或淡金色）
3
- **瓶盖**：金色或香槟色的金属盖子，设计精致优雅
4
- **背景**：米色或米黄色的简洁背景
5
- **光影效果**：侧光照射，产生清晰的影子，凸显产品的质感和高级感
6
- **风格**：整体呈现出高端护肤品、粉底液、或香水的专业产品形象
7
这类产品通常属于**化妆品或美妆护肤品类**，包装设计显得简约而奢华。

1
from langchain.chat_models import init_chat_model
2
from dotenv import load_dotenv
3

4
load_dotenv()
5
load_dotenv(override=True)
6
model = init_chat_model(
7
    model="deepseek:deepseek-v4-flash",
8
    extra_body={"thinking": {"type": "enabled"}},
9
)
10
response = model.invoke("你好，一句话回答")
11
print('=' * 20, '-> response <-', '=' * 20)
12
print(response)
13
print('=' * 20, '-> response.content <-', '=' * 20)
14
print(response.content)
15
print('=' * 20, '-> response.content_blocks <-', '=' * 20)
16
print(response.content_blocks)

1
==================== -> response <- ====================
2
content='你好，请说出您的问题，我会用一句话回答。' additional_kwargs={'refusal': None, 'reasoning_content': '好的，用户说"一句话回答"，那说明他希望我回答得简洁直接。没有具体问题，可能是测试或者玩笑。我需要确保回应既符合"一句话"的要求，又有礼貌。可以用"你好"开头，确认收到指令，然后表明已经准备好回答任何问题。这样既简洁又完整。'} response_metadata={'token_usage': {'completion_tokens': 76, 'prompt_tokens': 8, 'total_tokens': 84}, 'model_provider': 'deepseek', 'model_name': 'deepseek-v4-flash', 'finish_reason': 'stop'} id='lc_run--019e4b28-6b9b-7f11-bfe6-84aca4ecc4dc-0' tool_calls=[] invalid_tool_calls=[] usage_metadata={'input_tokens': 8, 'output_tokens': 76, 'total_tokens': 84}
3
==================== -> response.content <- ====================
4
你好，请说出您的问题，我会用一句话回答。
5
==================== -> response.content_blocks <- ====================
6
[{'type': 'reasoning', 'reasoning': '好的，用户说"一句话回答"，那说明他希望我回答得简洁直接。没有具体问题，可能是测试或者玩笑。我需要确保回应既符合"一句话"的要求，又有礼貌。可以用"你好"开头，确认收到指令，然后表明已经准备好回答任何问题。这样既简洁又完整。'}, {'type': 'text', 'text': '你好，请说出您的问题，我会用一句话回答。'}]

1
# 导入相关依赖
2
from langchain_core.prompts import ChatPromptTemplate
3

4
# 定义聊天提示词模版
5
chat_template = ChatPromptTemplate.from_messages(
6
    [
7
        ("system", "你是一个有帮助的AI机器人，你的名字是{name}。"),
8
        ("human", "你好，最近怎么样？"),
9
        ("ai", "我很好，谢谢！"),
10
        ("human", "{user_input}"),
11
    ]
12
)
13
# 格式化聊天提示词模版中的变量
14
prompt = chat_template.invoke({"name":"小明", "user_input":"你叫什么名字？"})
15
# 打印格式化后的聊天提示词模版内容
16
print(prompt)

1
messages=[SystemMessage(content='你是一个有帮助的AI机器人，你的名字是小明。', additional_kwargs={}, response_metadata={}), HumanMessage(content='你好，最近怎么样？', additional_kwargs={}, response_metadata={}), AIMessage(content='我很好，谢谢！', additional_kwargs={}, response_metadata={}, tool_calls=[], invalid_tool_calls=[]), HumanMessage(content='你叫什么名字？', additional_kwargs={}, response_metadata={})]

1
from langchain_core.prompts import ChatPromptTemplate
2

3
# 参数类型这里使用的是tuple构成的list
4
prompt_template = ChatPromptTemplate([
5
    # 字符串 role + 字符串 content
6
    ("system", "你是一个AI开发工程师. 你的名字是 {name}."),
7
    ("human", "你能开发哪些AI应用?"),
8
    ("ai", "我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等."),
9
    ("human", "{user_input}")
10
])
11
# 调用invoke()方法，返回ChatPromptValue
12
prompt = prompt_template.invoke({"name":"小谷AI", "user_input":"你能帮我做什么?"})
13
print(prompt)

1
from langchain_core.prompts import ChatPromptTemplate
2

3
# 参数类型这里使用的是tuple构成的list
4
prompt_template = ChatPromptTemplate([
5
    # 字符串 role + 字符串 content
6
    ("system", "你是一个AI开发工程师. 你的名字是 {name}."),
7
    ("human", "你能开发哪些AI应用?"),
8
    ("ai", "我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等."),
9
    ("human", "{user_input}")
10
])
11
prompt = prompt_template.invoke({"name":"小谷AI", "user_input":"你能帮我做什么?"})
12
print(type(prompt))
13
print(prompt)
14
print(len(prompt.messages))

1
<class 'langchain_core.prompt_values.ChatPromptValue'>
2
messages=[SystemMessage(content='你是一个AI开发工程师. 你的名字是 小谷AI.', additional_kwargs={}, response_metadata={}), HumanMessage(content='你能开发哪些AI应用?', additional_kwargs={}, response_metadata={}), AIMessage(content='我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等.', additional_kwargs={}, response_metadata={}), HumanMessage(content='你能帮我做什么?', additional_kwargs={}, response_metadata={})]

1
from langchain_core.prompts import ChatPromptTemplate
2

3
prompt_template = ChatPromptTemplate([
4
    ("system", "你是一个AI开发工程师. 你的名字是 {name}."),
5
    ("human", "你能开发哪些AI应用?"),
6
    ("ai", "我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等."),
7
    ("human", "{user_input}")
8
])
9
# 方式1：调用format()方法，返回字符串
10
prompt = prompt_template.format(name="小谷AI", user_input="你能帮我做什么?")
11
print(type(prompt))
12
print(prompt)

1
<class 'str'>
2
System: 你是一个AI开发工程师. 你的名字是 小谷AI.
3
Human: 你能开发哪些AI应用?
4
AI: 我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等.
5
Human: 你能帮我做什么?

1
from langchain_core.prompts import ChatPromptTemplate
2

3
prompt_template = ChatPromptTemplate([
4
    ("system", "你是一个AI开发工程师. 你的名字是 {name}."),
5
    ("human", "你能开发哪些AI应用?"),
6
    ("ai", "我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等."),
7
    ("human", "{user_input}")
8
])
9
# 调用format_messages()方法，返回消息列表
10
prompt = prompt_template.format_messages(name="小谷AI", user_input="你能帮我做什么?")
11
print(type(prompt))
12
print(prompt)

1
<class 'list'>
2
[SystemMessage(content='你是一个AI开发工程师. 你的名字是 小谷AI.', additional_kwargs={}, response_metadata={}), HumanMessage(content='你能开发哪些AI应用?', additional_kwargs={}, response_metadata={}), AIMessage(content='我能开发很多AI应用, 比如聊天机器人, 图像识别, 自然语言处理等.', additional_kwargs={}, response_metadata={}, tool_calls=[], invalid_tool_calls=[]), HumanMessage(content='你能帮我做什么?', additional_kwargs={}, response_metadata={})]

1
from dotenv import load_dotenv
2
from langchain_core.prompts import ChatPromptTemplate
3
import os
4
from langchain.chat_models import init_chat_model
5

6
###### 1、提供大模型 #########
7
load_dotenv(override=True)
8
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
9
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
10
model = init_chat_model(
11
    model="gpt-5.4-mini",
12
    model_provider="openai",
13
    api_key=CLOSEAI_API_KEY,
14
    base_url=CLOSEAI_BASE_URL
15
)
16
###### 2、提供提示词 #########
17
chat_prompt = ChatPromptTemplate.from_messages([
18
    ("system", "你是一个数学家，你可以计算任何算式"),
19
    ("human", "{text}"),
20
])
21
# 输入提示
22
prompt_value = chat_prompt.invoke({
23
    "text": "我今年18岁，我的舅舅今年38岁，我的爷爷今年72岁，我和舅舅一共多少岁了？"
24
})
25
###### 3、结合提示词，调用大模型 #########
26
# 得到模型的输出
27
output = model.invoke(prompt_value)
28
# 打印输出内容
29
print(output.content)

1
你今年 18 岁，舅舅今年 38 岁。
2
一共是：
3
18 + 38 = **56 岁**
4
所以，你和舅舅一共 **56 岁**。

1
def __init__(self,
2
             messages: Sequence[BaseMessagePromptTemplate | BaseMessage |
3
             BaseChatPromptTemplate | tuple[str | type, str | list[dict] | list[object]] |
4
             str | dict[str, Any]],
5
             *,
6
             template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
7
             **kwargs: Any) -> None

1
@classmethod
2
def from_messages(cls,
3
                  messages: Sequence[BaseMessagePromptTemplate | BaseMessage
4
                  | BaseChatPromptTemplate | tuple[str | type, str | list[dict] | list[object]]
5
                  | str | dict[str, Any]],
6
                  template_format: Literal["f-string", "mustache", "jinja2"] = "f-string")
7
    -> ChatPromptTemplate

1
# 1.导入相关依赖
2
from langchain_core.prompts import ChatPromptTemplate
3

4
# 2.定义聊天提示词模版
5
chat_template = ChatPromptTemplate.from_messages(
6
    [
7
        "Hello, {name}!"  # 等价于 ("human", "Hello, {name}!")
8
    ]
9
)
10
# 3. 使用invoke执行
11
messages = chat_template.invoke({"name":"小谷AI"})
12
# 4.打印格式化后的聊天提示词模版内容
13
print(messages)

1
messages=[HumanMessage(content='Hello, 小谷AI!', additional_kwargs={}, response_metadata={})]

1
# 示例: 元组形式的消息
2
prompt = ChatPromptTemplate.from_messages([
3
    ("system", "你的名字是{role}."),
4
    ("human", "很高兴认识你"),
5
])
6
print(prompt.invoke({"role":"小智"}))

1
messages=[SystemMessage(content='你的名字是小智.', additional_kwargs={}, response_metadata={}), HumanMessage(content='很高兴认识你', additional_kwargs={}, response_metadata={})]

1
# 示例: 字典形式的消息
2
prompt = ChatPromptTemplate.from_messages([
3
    {"role": "system", "content": "你的名字是{role}."},
4
    {"role": "human", "content": "很高兴认识你"},
5
])
6
print(prompt.invoke({"role":"小智"}))

1
messages=[SystemMessage(content='你的名字是小智.', additional_kwargs={}, response_metadata={}), HumanMessage(content='很高兴认识你', additional_kwargs={}, response_metadata={})]

1
from langchain_core.messages import SystemMessage,HumanMessage
2

3
chat_prompt_template = ChatPromptTemplate.from_messages([
4
    SystemMessage(content="我是一个贴心的智能助手"),
5
    HumanMessage(content="我的问题是:人工智能英文怎么说？")
6
])
7
messages = chat_prompt_template.invoke({})
8
print(messages)
9
print(type(messages))

1
messages=[SystemMessage(content='我是一个贴心的智能助手', additional_kwargs={}, response_metadata={}), HumanMessage(content='我的问题是:人工智能英文怎么说？', additional_kwargs={}, response_metadata={})]
2
<class 'langchain_core.prompt_values.ChatPromptValue'>

1
from langchain_core.messages import SystemMessage,HumanMessage
2

3
chat_prompt_template = ChatPromptTemplate.from_messages([
4
    SystemMessage(content="我是一个贴心的智能助手"),
5
    HumanMessage(content="我的问题是:{word}英文怎么说？")
6
])
7
messages = chat_prompt_template.invoke({"word":"人工智能"})
8
print(messages)
9
print(type(messages))

1
messages=[SystemMessage(content='我是一个贴心的智能助手', additional_kwargs={}, response_metadata={}), HumanMessage(content='我的问题是:{word}英文怎么说？', additional_kwargs={}, response_metadata={})]
2
<class 'langchain_core.prompt_values.ChatPromptValue'>