LangChain组件

from langchain_ollama import OllamaLLM

# 初始化模型
# 确保你已经在终端运行了: ollama run qwen2.5
model = OllamaLLM(model="qwen2.5") 

# 调用模型
res = model.invoke(input="你是谁呀能做什么？")

print(res)

from langchain_community.llms.tongyi import Tongyi

def stream_chat_tongyi(user_input, model_name="qwen-max"):
    """
    注意：需提前配置环境变量 DASHSCOPE_API_KEY
    """
    # 1. 初始化模型
    model = Tongyi(model=model_name)
    
    # 2. 调用 stream 方法获取生成器
    # 注意：LangChain 新版本建议使用 model.stream(user_input)
    res = model.stream(user_input)
    
    # 3. 循环获取并打印结果
    print(f"[{model_name} 正在思考]: ", end="")
    for chunk in res:
        # flush=True 确保文字能实时蹦出来，而不是等缓冲区满了才显示
        print(chunk, end="", flush=True)
    print("\n" + "-"*20)

if __name__ == "__main__":
    stream_chat_tongyi("你是谁呀？能做什么？")

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage

# 1. 初始化聊天模型
# 注意：确保环境变量 DASHSCOPE_API_KEY 已配置
chat = ChatTongyi(model="qwen-max")

# 2. 构造对话上下文（这就是所谓的“给模型喂记忆”）
messages = [
    SystemMessage(content="你是一名来自边塞的诗人"),
    HumanMessage(content="给我写一首五言绝句"),
    AIMessage(content="大漠孤烟直，长河落日圆。萧关逢候骑，都护在燕然。"),
    HumanMessage(content="仿照上一首的格式，自由发挥一首")
]

# 3. 利用 Runnable 接口的 stream 方法流式输出
# 此时 input 接收的是消息列表
for chunk in chat.stream(input=messages):
    # 注意：ChatModel 的 chunk 是一个消息对象，内容在 .content 里
    print(chunk.content, end="", flush=True)

print("\n" + "-"*20)

from langchain_community.chat_models.tongyi import ChatTongyi
model = ChatTongyi(model="qwen-max")
# 简写形式：("角色", "内容")
#（角色，内容） 角色：system/human/ai
messages = [
    ("system", "你是一名来自边塞的诗人。"),
    ("human", "写一首唐诗"),
    ("ai", "锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦。"),
    ("human", "按照你上一个回复的格式，再写一首唐诗。")
]
for chunk in model.stream(messages):
    print(chunk.content, end="", flush=True)

# 不管你是 chat_tongyi 还是 chat_ollama 还是 chat_gpt4
# 调用的姿势永远统一：
res = chat.invoke(messages) 
# 或者
for chunk in chat.stream(messages):
    ...

def get_model(provider="tongyi"):
    if provider == "tongyi":
        from langchain_community.chat_models.tongyi import ChatTongyi
        return ChatTongyi(model="qwen-max")
    elif provider == "ollama":
        from langchain_ollama import ChatOllama
        return ChatOllama(model="qwen2.5")

# 业务代码里只需要这一行，想换模型改个参数就行
chat = get_model("ollama")
chat.invoke("你好")

from langchain.model_laboratory import init_chat_model

# 只需要传模型名，它会自动帮你去后台找对应的包
model = init_chat_model("qwen-max", model_provider="tongyi")

from langchain_ollama import OllamaEmbeddings
embed = OllamaEmbeddings(model="qwen3-embedding")
print(embed.emb_query("111"))
print(embed.embed_documents(['1','2','3']))

from langchain_core.prompt import PromptTemplate
from langchain_community.llms.tongyi import Tongyi
# lastname = "张"gender="女儿"
# s=f"我的邻居姓{lastname}，刚生了{gender}，你帮我起个名字，简单回答。"
# 字符串这种写法加入不到chain中,因为
prompt_template = PromptTemplate.from_Template(
	"我的领居姓{lastname},刚生了{gender},你帮我起一个名字,简单回答一下"
)
# 调用format
prompt_text = prompt_template.format(lastname="张",gender="女儿")

model = Tongyi(model="qwen-max)
res = model.invoke(input = prompt_text)
print(res)

#另一种 chain链
chain = prompt_template | model
res = chain.invoke(input = {"lastname":"张","gender":"女儿"})
print(res)

from langchain_core.prompts import FewShotPromptTemplate

template = FewShotPromptTemplate(
    examples=None,
    example_prompt=None,
    prefix=None,
    suffix=None,
    input_variables=None
)

from langchain_core.prompts import PromptTemplate,FewShotPromptTemplate
#调用模型
from langchain_community.llms.tongyi import Tongyi
example_template = PromptTemplate.from_template("单词:{word},反义词:{antonym}")
example_data = [
    {"word":"大","antonym":"小"},
    {"word":"上","antonym":"下"},
]
# FewShotPromptTemplate(example_prompt=None,examples=None,prefix=None,suffix=None,input_variables=[])
FewShotPromptTemplate(
	example_prompt=None,  #示例数据的模板
	examples=None,        #示例的数据（用来注入动态数据的），1ist内套字典
	prefix=None,          #示例之前的提示词
	suffix=None,          #示例之后的提示词
	input_variables=[]    #声明在前缀或后缀中所需要注入的变量名
)

from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate
from langchain_community.llms.tongyi import Tongyi
# 1. 定义单个例子的格式
example_template = PromptTemplate.from_template("单词: {word}, 反义词: {antonym}")
# 2. 准备示例数据
examples_data = [
    {"word": "大", "antonym": "小"},
    {"word": "上", "antonym": "下"}
]
# 3. 配置少样本模板
few_shot_template = FewShotPromptTemplate(
    examples=examples_data,
    example_prompt=example_template,
    prefix="告知我单词的反义词，我提供如下的示例：",
    suffix="基于前面的示例告知我，{input_word}的反义词是？",
    input_variables=["input_word"]
)
# 4. 生成最终提示词并调用
prompt_text = few_shot_template.invoke({"input_word": "左"}).to_string()
model = Tongyi(model="qwen-max")
print(model.invoke(input=prompt_text))

from langchain_core.messages import AIMessage
from langchain_core.prompts import PromptTemplate
from langchain_core.prompts import FewShotPromptTemplate
from langchain_core.prompts import ChatPromptTemplate

"""
继承关系背后的逻辑：
PromptTemplate -> StringPromptTemplate -> BasePromptTemplate -> RunnableSerializable -> Runnable
FewShotPromptTemplate -> StringPromptTemplate -> BasePromptTemplate -> RunnableSerializable -> Runnable
ChatPromptTemplate -> BaseChatPromptTemplate -> BasePromptTemplate -> RunnableSerializable -> Runnable
"""

# 1. 实例化模板
template = PromptTemplate.from_template("我的邻居是: {lastname}, 最喜欢: {hobby}")

# 2. 传统格式化方式：返回纯字符串 (str)
res = template.format(lastname="张大明", hobby="钓鱼")
print(res, type(res))

# 3. 链式调用接口方式：返回 StringPromptValue 对象
# 只有实现了 Runnable 接口，才能使用 invoke，也才能接入 | 管道符
res2 = template.invoke({"lastname": "周杰伦", "hobby": "唱歌"})
print(res2, type(res2))