import os
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()

client = OpenAI(
    api_key=os.environ.get('DEEPSEEK_API_KEY'),
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "你是一个名侦探柯南里面的黑羽快斗（怪盗基德），请你用撩妹的方式和我对话"},
        {"role": "user", "content": "工藤新一你认识吗？他好像是你的兄弟是不是？"},
    ],
    stream=False,
    extra_body={"thinking": {"type": "disabled"}}
)
print(response.choices[0].message.content)

import os
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()

client = OpenAI(
    api_key=os.environ.get('DEEPSEEK_API_KEY'),
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "你是一个名侦探柯南里面的黑羽快斗（怪盗基德），请你用撩妹的方式和我对话"},
        {"role": "user", "content": "工藤新一你认识吗？他好像是你的兄弟是不是？"},
    ],
    stream=True,
    temperature=1.9, # 最大随机输出
    extra_body={"thinking": {"type": "enabled"}}
)
for chunk in response:
    if chunk.choices:
        delta = chunk.choices[0].delta
        if delta.reasoning_content:
            print(f"{delta.reasoning_content}", end="", flush=True)
        if delta.content:
            print(delta.content, end="", flush=True)

from dotenv import load_dotenv
from langchain.agents import create_agent
from langchain.messages import HumanMessage, SystemMessage
load_dotenv()

client = create_agent(model="deepseek-v4-flash")
response = client.invoke(
   {
       "messages":[SystemMessage("你是名侦探柯南里面的角色之圆谷光彦，请你用他的口吻回答我的问题"),
                   HumanMessage("你是谁")]
   },
   temperature=1.9, # 最大随机输出
   extra_body={ "thinking": { "type": "disabled" } },
)
for message in response["messages"]:
    message.pretty_print()

from dotenv import load_dotenv
from langchain.agents import create_agent
from langchain.messages import HumanMessage, SystemMessage
load_dotenv()

client = create_agent(model="deepseek-v4-flash")
response = client.stream(
   {
       "messages":[SystemMessage("你是名侦探柯南里面的角色之琴酒，请你用他的口吻回答我的问题"),
                   HumanMessage("你是谁")]
   },
   temperature=1.9, # 最大随机输出
   stream_mode="messages",
   extra_body={ "thinking": { "type": "disabled" } },
)
for token,metadata in response:
    if token.content:
        print(token.content, end="", flush=True) # flush=True 强制立即将缓冲区内容写入终端，而不是等缓冲区满或程序结束再输出。

from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage, SystemMessage
model = init_chat_model(model="deepseek-v4-flash")
#  model.stream() 不接受 {"messages": [...]}，要直接传消息列表
response = model.stream(
    [
        SystemMessage("你是名侦探柯南里面的角色之伏特加，请你用他的口吻回答我的问题"),
        HumanMessage("你是谁")
    ],
    temperature=1.9,
    extra_body={"thinking": {"type": "disabled"}},
)
for chunk in response:
    if chunk.content:
        print(chunk.content, end="", flush=True)
print()

model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",  # 兼容 OpenAI 协议
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key=os.getenv("DASHSCOPE_API_KEY")
)

# 非支持模型无法自动加载环境遍历，我们需要自己加载环境变量中的base_url和api_key
import os
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage, SystemMessage
from dotenv import load_dotenv
load_dotenv()
base_url = os.getenv("DASHSCOPE_BASE_URL")
api_key = os.getenv("DASHSCOPE_API_KEY")

# 初始化模型
model = init_chat_model(
    model="qwen-plus", # 模型名称，这里可以自定义，我们用的是阿里的qwen-max
    model_provider="openai", # 如果是Langchain不支持的模型，需要指定模型提供者（虽然我们用的是阿里，但是阿里兼容openai，所以这里用openai，就是默认采用openai的API规范）
    base_url=base_url,
    api_key=api_key,
    temperature = 1.2,
    max_tokens = 512,

)
print(type(model)) # <class 'langchain_openai.chat_models.base.ChatOpenAI'>

response = model.stream([
    SystemMessage("你是名侦探柯南里面的角色之阿笠博士，请你用他的口吻回答我的问题"),
    HumanMessage("你是谁")
])

for chunk in response:
    if chunk.content:
        print(chunk.content, end="", flush=True)

HumanMessage(content=[
    {"type": "image", "url": "https://example.com/photo.jpg"},  # 图片
    {"type": "text", "text": "帮我看看这个地方是哪里"}           # 文字
])

from langchain.chat_models import init_chat_model
import os
from langchain.agents import create_agent

# 1.初始化模型
model = init_chat_model(
    model="qwen3.5-plus",  # 这里选择qwen3.5-plus，这是一个多模态模型，支持图片、文本、音频、视频
    model_provider="openai",
    base_url=os.getenv("DASHSCOPE_BASE_URL"),
    api_key=os.getenv("DASHSCOPE_API_KEY")
)

# 2.创建智能体
agent = create_agent(model=model)

# 3.组织多模态消息
multimodal_message = HumanMessage(
    content=[
        {"type": "image",
         "url": "https://img.heiseven.top/file/background/1780808095892_【哲风壁纸】8k-风景.png"},
        {"type": "text", "text": "帮我看看这个地方是哪里，帮我规划一下"}
    ])

# 4.调用Agent，发送多模态消息
for token, metadata in agent.stream({
    "messages": [multimodal_message]
}, stream_mode="messages"):
    if token.content:
        print(token.content, end="", flush=True)

agent = create_agent(
    model="deepseek-chat",
    system_prompt="像海盗一样说话."
)

from langchain.agents import create_agent
from langchain.messages import HumanMessage

# 创建智能体
agent = create_agent(
    model = "deepseek-chat",
    system_prompt="像海盗一样说话."
)

for token, metadata in agent.stream(
    {"messages": [HumanMessage(content="你是谁？")]},
    stream_mode="messages"
):
    print(token.content, end="", flush=True)

from langchain.agents import create_agent
from langchain.messages import HumanMessage
system_prompt = """
# 身份
- 你是一个科幻作家，根据用户的要求创建一个太空之都。

# 指令
- 请务必以JSON格式输出，不要加任何markdown样式。

# 示例：
user: 月球的首都是什么？
assistant:
{
    "name": "月华市（Lunaria）",
    "location": "位于月球正面赤道附近的静海基地遗址之上，依托巨大的穹顶与地下网络建成",
    "vibe": "冷冽、高效、革新",
    "economy": "氦-3能源开采、量子通信枢纽、尖端生物圈农业"
}
"""

agent = create_agent(
    model="deepseek-chat",
    system_prompt=system_prompt
)

response = agent.invoke(
    {"messages": [HumanMessage(content="金星的首都是什么?")]},
)

print(response['messages'][-1].content)

class CapitalInfo(BaseModel):
    name: str
    location: str
    vibe: str
    economy: str

agent = create_agent(
    model="deepseek-chat",
    response_format=CapitalInfo  # 绑定 Schema
)

from pydantic import BaseModel
from langchain.agents import create_agent
from langchain.messages import HumanMessage

# 首先，我们定义一个类，用来封装模型要输出的数据：
class CapitalInfo(BaseModel):
    name: str
    location: str
    vibe: str
    economy: str

# 然后，我们就可以创建智能体并设置结构化输出的格式了。
agent = create_agent(
    model='deepseek-chat',
    system_prompt="你是一个科幻作家，根据用户的要求创建一个太空之都。",
    response_format=CapitalInfo # 设置结构化输出的格式
)

response = agent.invoke(
    {"messages": [HumanMessage(content="月球的首都是什么?")]}
)

city = response['structured_response']
print(city)

print(f"{city.name}位于{city.location}，是一座{city.vibe}的城市，其主要产业包括{city.economy}。")

@tool
def get_weather(location: str) -> str:
    """Get the weather in a given location."""
    return f"Current weather in {location} is sunny"

# 1.使用tool装饰器定义工具
from langchain.tools import tool
from langchain.agents import create_agent
from langchain_core.messages import HumanMessage

@tool
def get_weather(location: str) -> str:
    """
    Get the weather in a given location.
    Args:
        location: city name or coordinates
    """
    return f"Current weather in {location} is sunny"

# 2.创建智能体，并绑定工具
agent = create_agent(
    model="deepseek-chat",
    tools=[get_weather]
)

# 3.调用Agent
response = agent.invoke(
    {"messages": [HumanMessage(content="杭州今天天气如何?")]},
)

for message in response['messages']:
    message.pretty_print()

class WeatherInput(BaseModel):
    location: str = Field(description="City name")
    units: Literal["celsius", "fahrenheit"] = Field(default="celsius")
    include_forecast: bool = Field(default=False)

@tool(args_schema=WeatherInput)
def get_weather(location: str, units: str = "celsius", ...) -> str:
    ...

# 例如一个查询天气的tool
from typing import Literal

from pydantic import Field


class WeatherInput(BaseModel):
    """查询天气的输入参数."""
    location: str = Field(description="City name or coordinates")
    units: Literal["celsius", "fahrenheit"] = Field(
        default="celsius",
        description="Temperature unit preference"
    )
    include_forecast: bool = Field(
        default=False,
        description="Include 5-day forecast"
    )

    # 定义一个查询天气的tool
@tool(args_schema=WeatherInput)
def get_weather(location: str, units: str = "celsius", include_forecast: bool = False) -> str:
    """Get current weather and optional forecast."""
    temp = 22 if units == "celsius" else 72
    result = f"Current weather in {location}: {temp} degrees {units[0].upper()}"
    if include_forecast:
        result += "\nNext 5 days: Sunny"
    return result

response = get_weather.invoke({"location": "杭州", "include_forecast": True})
print(response)

from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(model="...", checkpointer=InMemorySaver())
config = {"configurable": {"thread_id": "thread_1"}}
agent.invoke(input, config)
# langchain提供的checkpointer的默认实现，基于内存存储
from langgraph.checkpoint.memory import InMemorySaver
from langchain.agents import create_agent

# 创建智能体时指定checkpointer，LangChain会自动帮我们管理历史会话记忆
agent = create_agent(
    "deepseek-v4-flash",
    checkpointer=InMemorySaver()
)

from langchain.messages import HumanMessage

# 设定thread_id，作为会话标识
config = {"configurable": {"thread_id": "thread_1"}}

# 第一次调用，告知AI我的信息
response = agent.invoke(
    {"messages": [HumanMessage(content="你好，我是Seven，我的个人博客是blog.heiseven.top")]},
    config # 调用时添加thread_id，区分不同会话
)

for message in response['messages']:
    message.pretty_print()

# 第二次调用，询问我的信息，这次带上thread_id，唤起记忆
response = agent.invoke(
    {"messages": [HumanMessage(content="我叫什么？我有什么作品？")]},
    config # 调用时添加thread_id
)

for message in response['messages']:
    message.pretty_print()

# 以此类推.....

import os
import sqlite3
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage
from langgraph.checkpoint.sqlite import SqliteSaver
from langchain.agents import create_agent

load_dotenv()

# 1. 初始化 SQLite 数据库连接并创建 checkpointer
# 使用连接池或直接连接文件，SqliteSaver 会在后台自动打理好一切，甚至不需要手动调用 .setup()
db_connection = sqlite3.connect("./db/checkpoint.db", check_same_thread=False)
checkpointer = SqliteSaver(db_connection)

# 2. 初始化大模型（把“发动机”实例化出来）
model = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="openai",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

agent = create_agent(
    model=model,
    checkpointer=checkpointer,
)

# 4. 【核心修复】必须指定 thread_id，这就好比给当前聊天的用户开辟一个专属的聊天室编号
config = {"configurable": {"thread_id": "user_session_1"}}

# 5. 调用 agent 并开启消息流模式
response = agent.stream(
    {"messages": [HumanMessage(content="你好，还记得我吗？我是一只在学 Python 的小狐狸。")]},
    config=config,  # ⚠️ 必须传入配置项
    stream_mode="messages"
)

# 6. 精准流式打印大模型的正文
for chunk, metadata in response:
    if chunk.content:
        print(chunk.content, end="",flush=True)