• temperature：温度，控制生成文本的“随机性”，取值范围为0~1
  • 值越低 -->输出越确定、保守（适合事实回答）
  • 值越高 -->输出越多样、有创意（适合创意写作）

　　　通常，根据需要设置如下：

1. 精确模式（0.5或更低）：生成的文本更加安全可靠，但可能缺乏创意或多样性
2. 平衡模式（通常是0.8）：生成的文本通常既有一定的多样性，又能保持较好的连贯性和准确性
3. 创意模式（通常是1）：生成的文本更有创意 、但也更容易出现语法错误或者逻辑不合理的内容

• max_tokens：限制生成文本的最大长度，防止输出过长
• Token是什么？----->简单可理解为Byte(字节)
• • • • 基本单位：大模型处理文本的最小单位是token，输出时逐个token依次生成
      • 收费依据：大预言模型（LLM）通常也是以token的数量作为其计量（或收费）的依据

        • 1个Token≈1-1.8个汉字，1个Token≈3-4个英文字母

        • Token与字符转化的可视化工具：

          OpenAI提供：https://platform.openai.com/tokenizer

          百度智能云提供：https://console.bce.baidu.com/support/#/tokenize

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
load_dotenv()
'''
采用配置文件的方式加载对话模型
1、在项目根目录创建.env文件，添加如下配置项
OPENAI_API_BASE_URLL=你的openai api base url
OPENAI_API_KEYY=你的openai api key
2、在代码中通过os.getenv()方法获取配置项的值
3、将获取到的值传递给ChatOpenAI类的base_url和api_key参数
'''

llm=ChatOpenAI(
    model="gpt-4o-mini",
    base_url=os.getenv("OPENAI_API_BASE_URLS"),
    api_key= os.getenv("OPENAI_API_KEY1"),
    temperature=0.7,
    max_tokens=200
)

res=llm.invoke("RAG技术的核心流程")
print(res.content)

# 当然可以给os内部环境变量赋值 -->如果model采用默认的模型，ChatOpenAI()初始化时可以不传base_url和api_key参数

os.environ["OPENAI_BASE_URL"]=os.getenv("OPENAI_BASE_URLS")
os.environ["OPENAI_API_KEY"]=os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI()
response = chat.invoke("请简要介绍一下RAG技术的核心流程")
print(response.content)

注意：
FunctionMessage和ToolMessage分别是在函数调⽤和⼯具调⽤场景下才会使⽤的特殊消息类
型，HumanMessage、AIMessage和SystemMessage才是最常⽤的消息类型。

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key
)

message = [
    SystemMessage(content="你是一个擅长人工智能的相关学科的专家"),
    HumanMessage(content="请用中文解释一下什么是机器学习")
]
response = chat.invoke(message)
print(response.content)
print(type(response)) #打印查看到大模型执行后返回的对象类型=AIMessage

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

dotenv.load_dotenv() #加载配置文件
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
    streaming=True
)

message = [
    SystemMessage(content="你是一个擅长编程的专家"),
    HumanMessage(content="请用Python写一个冒泡排序的代码")
]
# 流式输出，模型执行返回的结果是一个生成器对象，所以可以使用for循环进行迭代输出
response = chat.stream(message)
for chunk in response:
    print(chunk.content, end='', flush=True)
print(type(response)) #打印查看到大模型执行后返回的对象类型=Generator

#批量处理
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

dotenv.load_dotenv() #加载配置文件
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key
)

message1 = [
    SystemMessage(content="你是一个擅长编程的专家"),
    HumanMessage(content="请用Python写一个冒泡排序的代码")
]
message2 = [
    SystemMessage(content="你是一个擅长历史的专家"),
    HumanMessage(content="请简要介绍一下二战的起因")
]
messages = [message1, message2]
response=chat.batch(messages)  #批量处理多个输入

print(type(response)) #打印查看到大模型执行后返回的对象类型<class 'list'>

for chunk in response:
    print(chunk.content) 

from langchain_core.prompts import PromptTemplate

## 方式一：使用构造方法

# 1、定义模版
tempalte=PromptTemplate(
    template="请用中文介绍一下{product}。",
    input_variables=["product"],
)
# 2、传入多个变量，生成最终的提示词
final_prompt=tempalte.format(product="LangChain")
final_prompt1 = tempalte.format(product="大模型")

print(final_prompt+'\n'+final_prompt1) # 执行结果: 请用中文介绍一下LangChain。
print(type(final_prompt)) # 执行结果: <class 'str'>

## 方式二：使用from_template类方法
# 1、定义模版
prompt_tempalte=PromptTemplate.from_template(
    template="你是一个{role}专家，请用{language}介绍一下{product}。"
)
# 2、传入模版中的变量名
prompt=prompt_tempalte.format(role="人工智能", language="中文", product="机器学习")

print(prompt) # 执行结果: 你是一个人工智能专家，请用中文介绍一下机器学习。
print(type(prompt)) # 执行结果: <class 'str'>

#方式一： 实例化过程中使用partial_variables参数
partial_prompt=PromptTemplate.from_template(
    template="你是一个{role}专家，请用{language}介绍一下{product}。",
    partial_variables={"role":"人工智能"}
)
prompt = partial_prompt.format(language = '中文', product='深度学习')
print(prompt) # 执行结果: 你是一个人工智能专家，请用中文介绍一下深度学习。

# 方式二：使用PromptTemplate.partial方法创建部分提示模版
base_prompt=PromptTemplate.from_template(
    template="你是一个{role}专家，请用{language}介绍一下{product}。",
)
partial_prompt=base_prompt.partial(role="编程")
prompt=partial_prompt.format(language="Python", product="函数式编程")
print(prompt) # 执行结果: 你是一个编程专家，请用Python介绍一下函数式编程。

from langchain_core.prompts import PromptTemplate
template = (
    PromptTemplate.from_template("Tell me a joke about {topic}")
    + ", make it funny"
    + "\n\nand in {language}"
)
prompt = template.format(topic="sports", language="spanish")
print(prompt)

tempalte = PromptTemplate.from_template("告诉我一段关于{topic}的历史")
prompt = tempalte.invoke({"topic": "二战"}) #传入的是一个字典 
print(prompt)
print(type(prompt)) #执行结果：<class 'langchain_core.prompt_values.StringPromptValue'>

from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
import os
import dotenv

# 1.加载环境配置文件
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

# 2.创建大模型对象   
chat = ChatOpenAI(
    model = "gpt-4o-mini",
    base_url= base_url,
    api_key= api_key
)

# 3.创建提示词模版并传入变量生成最终提示词
tempalte = PromptTemplate.from_template("请{name}告诉我一段关于{topic}的畅想")
prompt = tempalte.invoke({"name": "马斯克","topic": "移民火星"}) 

# 4.调用大模型的invoke方法进行问答
message = [
    SystemMessage(content="你是一个擅长历史的专家"),
    HumanMessage(content=prompt.to_string())
]   
response = chat.invoke(message)
print(response.content)

from langchain_core.prompts import ChatPromptTemplate


chat_prompt_template=ChatPromptTemplate(
    [
        ("system", "你是一个乐于助人的助手,你的名字是{name}。"),
        ("human", "我的问题是{question}。"),
    ]
)
responses = chat_prompt_template.invoke(input={"name":"小明", "question":"你是谁？"})
print(responses.to_string())
print(type(responses)) #<class 'langchain_core.prompt_values.ChatPromptValue'>

from langchain_core.prompts import ChatPromptTemplate
chat_prompt=ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个乐于助人的助手,你的名字是{name}。"),
        ("human", "我的问题是{question}。"),
    ]
)
template = chat_prompt.invoke(input={"name":"小红", "question":"你是谁？"})
print(template.to_string())
print(type(template))

'''
invoke()方法 :传入的是字典，返回的是ChatPromptValue对象
format()方法：传入变量的值，返回的是字符串
format_message()方法：传入变量的值，返回的是消息对象列表List[Message]
format_prompt()方法：传入变量的值，返回的是ChatPromptValue对象
'''
#如何实现ChatPromptValue与list[Message]、String 之间的转换

from langchain_core.prompts import ChatPromptTemplate
chat_prompt=ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个乐于助人的助手,你的名字是{name}。"),
        ("human", "我的问题是{question}。"),
    ]
)
template = chat_prompt.invoke(input={"name":"小红", "question":"你是谁？"}) # 返回的是ChatPromptValue对象

# ChatPromptValue 转换成 str类型 ---->to_string()函数
str_prompt = template.to_string() 
print(str_prompt)   
print(type(str_prompt))     

# ChatPromptValue 转换成 List[Message]类型 ---->to_messages()函数  
message_prompt = template.to_messages() 
print(message_prompt)   
print(type(message_prompt))

• MessagePlaceholder作用：当你不确定消息提示模版使用什么角色或者希望在格式化过程中插入消息列表时，可以使用MessagePlaceholder占位符在提示词模版中预留一个位置，后续可以动态插入消息列表

• 使用场景：多轮对话系统存储历史消息以及Agent的中间步骤 处理此功能非常有用

from langchain_core.prompts.chat import MessagesPlaceholder
from langchain_core.messages import AIMessage, HumanMessage
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os
import dotenv

#1、加载环境配置文件
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

#2、创建大模型对象
chat = ChatOpenAI(
    model = "gpt-4o-mini",
    base_url= base_url,
    api_key= api_key
)

#3、创建ChatPromptTemplate提示词模版并传入变量生成最终提示词
chat_prompt_template=ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个精通{role}的帮助助手，擅长回答各种问题。"),
        MessagesPlaceholder("history"),
        ("human", "{question}"),
    ]
)
prompt = chat_prompt_template.format_messages(
    role="数学",
    history=[
        HumanMessage(content="1+2*3等于多少？"),
        AIMessage(content="1+2*3等于7。"),
    ],
    question = "我刚才的问题是什么"
)
for context in prompt:
    print(context.content)

#4、调用大模型的invoke方法进行问答
response = chat.invoke(prompt)
print("\n"+response.content)

from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate
from langchain_openai import ChatOpenAI
import os
import dotenv


#1）创建提示模版，将一个示例格式化为字符串
prompt_template = "你是一个数学专家，输入:{input} 输出:{output} 描述:{description}"
prompt_template = PromptTemplate.from_template(prompt_template)

#2）提供实例
examples = [
    {"input": "2+2", "output": "4", "description": "加法运算"},
    {"input": "2x2", "output": "4", "description": "乘法运算"},
]

# 3）创建FewShotPromptTemplate对象
few_template = FewShotPromptTemplate(
    examples=examples, # 提供示例   
    example_prompt=prompt_template, # 指定示例的提示模版
    suffix="请你仿照上面的示例，根据：{input}，给出相应的output值和description描述。", #要放到示例模版后面的要求
    input_variables=["input"], # 用户输入变量
)

# 4) 提示词结合LLM使用
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)

res = chat.invoke(few_template.invoke({"input": "10-2"})) # 调用FewShotPromptTemplate的invoke方法，传入用户输入
print(res.content)

from langchain_core.prompts import FewShotChatMessagePromptTemplate, ChatPromptTemplate
from langchain_openai import ChatOpenAI
import os
import dotenv

# 目标：让模型先从示例中“归纳 🐦 这个运算符代表什么”，再用同一规则去算 10🐦2。

#1）创建示例组
examples = [
    {"input": "2🐦2", "output": "4"},
    {"input": "2🐦3", "output": "6"},
    {"input": "10🐦0", "output": "10"},
]

#2）创建示例用的 ChatPromptTemplate提示词模版（一问一答对齐风格）
example_chat_prompt = ChatPromptTemplate.from_messages(
    [
        ("human", "表达式：{input}"),
        ("ai", "结果：{output}"),
    ]
)

#3）Few-shot 示例消息
few_shot = FewShotChatMessagePromptTemplate(
    example_prompt=example_chat_prompt,
    examples=examples,
)

#4）最终提示：要求模型输出『规则』+『结果』+『推理』
final_prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个严谨的数学符号归纳助手。你会从给定示例中推断一个未知二元运算符的含义，并用该规则计算新表达式。",
        ),
        few_shot,
        (
            "human",
            "上面给了若干条『表达式 -> 结果』示例。请你完成两个任务：\n"
            "1) 归纳运算符 🐦 的含义（尽量用标准运算符 +、-、*、/ 或清晰的函数规则描述）。\n"
            "2) 使用你归纳出的规则，计算：{input}\n\n"
            "请严格按如下格式输出：\n"
            "规则：...\n"
            "结果：...\n"
            "推理：...",
        ),
    ]
)

# 5) 提示词结合LLM使用
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)

res = chat.invoke(final_prompt.invoke({"input": "10🐦2"}))
print(res.content)

# 第一步: 安装向量数据库 pip install chromadb
# 第二步：编写示例选择器代码

# 1.导入相关包
from langchain_community.vectorstores import Chroma
from langchain_core.example_selectors import SemanticSimilarityExampleSelector
import os
import dotenv
from langchain_openai import OpenAIEmbeddings
dotenv.load_dotenv()
# 2.定义嵌入模型
os.environ['OPENAI_API_KEY'] = os.getenv("OPENAI_API_KEY1")
os.environ['OPENAI_BASE_URL'] = os.getenv("OPENAI_BASE_URLS")
embeddings_model = OpenAIEmbeddings(
    model="text-embedding-3-small"
)
# 3.定义示例组
examples = [
            {
            "question": "谁活得更久，穆罕默德·阿里还是艾伦·图灵?",
            "answer": """
            接下来还需要问什么问题吗？
            追问：穆罕默德·阿里去世时多大年纪？
            中间答案：穆罕默德·阿里去世时享年74岁。
            """,
            },
            {
            "question": "craigslist的创始人是什么时候出生的？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：谁是craigslist的创始人？
            中级答案：Craigslist是由克雷格·纽马克创立的。
            """,
            },
            {
            "question": "谁是乔治·华盛顿的外祖父？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：谁是乔治·华盛顿的母亲？
            中间答案：乔治·华盛顿的母亲是玛丽·鲍尔·华盛顿。
            """,
            },
            {
            "question": "《大白鲨》和《皇家赌场》的导演都来自同一个国家吗？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：《大白鲨》的导演是谁？
            中级答案：《大白鲨》的导演是史蒂文·斯皮尔伯格。
            """,
            },
        ]
# 4.定义示例选择器
example_selector = SemanticSimilarityExampleSelector.from_examples(
    # 这是可供选择的示例列表
    examples,
    # 嵌入模型，用于将示例转换为向量
    embeddings_model,
    # 向量数据库，用于存储和检索示例向量
    Chroma,
    # 这是要生成的示例数量
    k=1,
)
# 选择与输入最相似的示例
question = "玛丽·鲍尔·华盛顿的父亲是谁?"
selected_examples = example_selector.select_examples({"question": question})
print(f"与输入最相似的示例：{selected_examples}")

_type:
    "prompt"
input_variables:
    ["name","what"]
template:
    "请给{name}讲一个关于{what}的故事"

## 调用yaml文件代码
from langchain_core.prompts import load_prompt
from dotenv import load_dotenv
load_dotenv()
prompt = load_prompt("prompt.yaml", encoding="utf-8")
# print(prompt)
print(prompt.format(name="年轻人", what="滑稽"))

{
  "_type": "prompt",
  "input_variables": [
    "name",
    "what"
  ],
  "template": "请{name}讲一个{what}的故事,"

## 调用json文件代码

from langchain_core.prompts import load_prompt
from dotenv import load_dotenv
load_dotenv()
prompt = load_prompt("prompt.json",encoding="utf-8")
print(prompt.format(name="张三",what="搞笑的"))

## 字符串解析器 StrOutputParser

from langchain_core.example_selectors import SemanticSimilarityExampleSelector
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate
import os
import dotenv
from openai import base_url, api_key
from langchain_community.vectorstores import Chroma
from langchain_core.output_parsers import StrOutputParser


#1、加载环境配置文件
dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

#2、创建大模型对象
chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)
#3、接入示例提示词来创建最终提示词模版
embeddings =  OpenAIEmbeddings(  #定义嵌入模型
    model="text-embedding-3-small",
    base_url=base_url,
    api_key=api_key,
)

examples = [ # 定义示例组
    {
            "question": "2025年AI技术取得了哪些重大突破？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：2026年AI技术可能会有哪些新的发展方向？
            中间答案：2026年AI技术可能会在太空AI，机器人自主学习等领域取得新的突破。
            """,
    },
    {
            "question": "谁是乔治·华盛顿的外祖父？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：谁是乔治·华盛顿的母亲？
            中间答案：乔治·华盛顿的母亲是玛丽·鲍尔·华盛顿。
            """,
    },
    {
            "question": "《大白鲨》和《皇家赌场》的导演都来自同一个国家吗？",
            "answer": """
            接下来还需要问什么问题吗？
            追问：《大白鲨》的导演是谁？
            中级答案：《大白鲨》的导演是史蒂文·斯皮尔伯格。
            """,
    }
]
example_selector = SemanticSimilarityExampleSelector.from_examples( #示例选择器把示例存入向量数据库
    examples,
    embeddings,
    Chroma,
    k=1
)

#4、调用大模型的invoke方法进行问答
# 定义示例在对话中的格式
example_prompt = ChatPromptTemplate.from_messages(
    [
        ("human", "{question}"),
        ("ai", "{answer}"),
    ]
)

# 直接把 example_selector 传给 PromptTemplate，这样它会自动根据用户的新输入，去向量库里检索最相关的示例，然后填入 Prompt
few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_selector=example_selector,  # 传入选择器，而不是写死的 examples 列表
    example_prompt=example_prompt,
)

# 构建最终的对话提示模版
final_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个智能问答助手。"),
        few_shot_prompt,
        ("human", "{question}"),
    ]
)

# 5、结合输出解析器 (Output Parser)
output_parser = StrOutputParser()

# 使用 LCEL (LangChain Expression Language) 链式调用
# 数据流向：用户输入 -> Prompt模板(自动检索示例+组装) -> Chat模型 -> 输出解析器 -> 纯文本
chain = final_prompt | chat | output_parser

res_text = chain.invoke(
    {"question": "马斯克和黄仁勋对话谈论2025年AI发展取得的成就以及2026年AI的发展前景"}
)

print(type(res_text))
print(res_text)

## Json解析器 JsonOutputParser
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate


dotenv.load_dotenv()
base_url = os.getenv("OPENAI_BASE_URLS")
api_key = os.getenv("OPENAI_API_KEY1")

chat = ChatOpenAI(
    model="gpt-4o-mini",
    base_url=base_url,
    api_key=api_key,
)

query = '请给我讲一个笑话'

#定义json输出解析器对象
json_parser  = JsonOutputParser()

# 定义提示词模版 -->关键点： template给到了2个变量：format_instructions 和 query，而partial_variables把format_instructions变量固定为json_parser.get_format_instructions()的值,所以用户只需要传入query这一个变量变量
prompt = PromptTemplate.from_template(
    template="回答用户的问题\n{format_instructions}\n{query}\n",
    partial_variables={"format_instructions": json_parser.get_format_instructions()}
)


# 使用LCEL链式调用: 提示词-->大模型 --> json输出解析器 【 | 叫管道符】
chain = prompt | chat | json_parser

res_json = chain.invoke({"query": query})

print(res_json)

# 创建解析器
output_parser = CommaSeparatedListOutputParser()

get_format_instructions()： 获取日期解析的格式化指令，指令为："Write a datetime string
that matches the following pattern: '%Y-%m-%dT%H:%M:%S.%fZ'。