# 最简单的 messages 格式
messages = [
    {"role": "user", "content": "你好！"}
]

# 返回的 reply
# assistant: "你好！有什么我可以帮你的吗？"

# 定义AI的角色和行为
messages = [
    {"role": "system", "content": "你是一个温柔的老师，说话要鼓励学生"},
    {"role": "user", "content": "我学不会编程怎么办？"}
]

# 返回的 reply
# assistant: "别担心，编程很有趣，我们从简单开始..."

# 对话历史会累积
messages = [
    {"role": "system", "content": "你是一个助手"},
    # 第一轮
    {"role": "user", "content": "什么是AI？"},
    {"role": "assistant", "content": "AI是人工智能..."},
    # 第二轮
    {"role": "user", "content": "它能做什么？"},
    {"role": "assistant", "content": "AI可以..."},
    # 第三轮
    {"role": "user", "content": "python怎么学？"},  # AI还记得之前的上下文
]

# ⚠️ 注意：每次请求都要把之前的对话历史都传进去！
# 模型没有记忆，你需要把历史都发给它

# 安装: pip install openai
from openai import OpenAI

# 初始化客户端
client = OpenAI(
    api_key="your-api-key",  # 替换为你的API Key
    base_url="https://api.openai.com/v1"
)

# 调用模型
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "你是一个专业助手"},
        {"role": "user", "content": "请解释什么是机器学习？"}
    ],
    temperature=0.7,
    max_tokens=1000
)

# 获取回复
print(response.choices[0].message.content)

# 安装: pip install anthropic
from anthropic import Anthropic

# 初始化客户端
client = Anthropic(
    api_key="your-api-key"  # 替换为你的API Key
)

# 调用模型
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1000,
    messages=[
        {"role": "user", "content": "请解释什么是深度学习？"}
    ]
)

# 获取回复
print(response.content[0].text)

# 安装: pip install qianfan
import qianfan

# 初始化客户端
client = qianfan.ChatCompletion(
    ak="your-access-key",      # 替换为你的AK
    sk="your-secret-key"       # 替换为你的SK
)

# 调用模型
response = client.do(
    model="ernie-4.5-8k",
    messages=[
        {"role": "user", "content": "请解释什么是自然语言处理？"}
    ],
    temperature=0.7,
    penalty_score=1.0
)

# 获取回复
print(response["body"]["result"])

# 安装: pip install dashscope
from dashscope import ChatCompletion

# 调用模型
response = ChatCompletion.call(
    model="qwen-max",
    messages=[
        {"role": "user", "content": "请解释什么是卷积神经网络？"}
    ],
    temperature=0.7,
    max_tokens=1000
)

# 获取回复
print(response.output.choices[0].message.content)

# 安装: pip install openai
from openai import OpenAI

# 初始化客户端（兼容OpenAI接口）
client = OpenAI(
    api_key="your-api-key",  # 替换为你的API Key
    base_url="https://api.deepseek.com/v1"
)

# 调用模型
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "user", "content": "请解释什么是Transformer架构？"}
    ],
    temperature=0.7,
    max_tokens=1000
)

# 获取回复
print(response.choices[0].message.content)

"""
统一的大语言模型调用封装
支持切换不同提供商
"""
from abc import ABC, abstractmethod
from typing import List, Dict

class LLMProvider(ABC):
    """LLM提供商抽象基类"""
    
    @abstractmethod
    def chat(self, messages: List[Dict], **kwargs) -> str:
        pass

class OpenAIProvider(LLMProvider):
    def __init__(self, api_key: str, model: str = "gpt-4o"):
        from openai import OpenAI
        self.client = OpenAI(api_key=api_key)
        self.model = model
    
    def chat(self, messages: List[Dict], temperature: float = 0.7, **kwargs) -> str:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            temperature=temperature,
            **kwargs
        )
        return response.choices[0].message.content

class DeepSeekProvider(LLMProvider):
    def __init__(self, api_key: str, model: str = "deepseek-chat"):
        from openai import OpenAI
        self.client = OpenAI(
            api_key=api_key,
            base_url="https://api.deepseek.com/v1"
        )
        self.model = model
    
    def chat(self, messages: List[Dict], temperature: float = 0.7, **kwargs) -> str:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            temperature=temperature,
            **kwargs
        )
        return response.choices[0].message.content

class QwenProvider(LLMProvider):
    def __init__(self, api_key: str, model: str = "qwen-max"):
        self.api_key = api_key
        self.model = model
    
    def chat(self, messages: List[Dict], temperature: float = 0.7, **kwargs) -> str:
        from dashscope import ChatCompletion
        response = ChatCompletion.call(
            model=self.model,
            messages=messages,
            temperature=temperature,
            **kwargs
        )
        return response.output.choices[0].message.content

# 工厂函数
def create_llm_provider(provider: str, api_key: str, model: str = None) -> LLMProvider:
    providers = {
        "openai": lambda: OpenAIProvider(api_key, model or "gpt-4o"),
        "deepseek": lambda: DeepSeekProvider(api_key, model or "deepseek-chat"),
        "qwen": lambda: QwenProvider(api_key, model or "qwen-max"),
    }
    return providers[provider.lower()]()

# 使用示例
if __name__ == "__main__":
    messages = [
        {"role": "system", "content": "你是一个专业助手"},
        {"role": "user", "content": "什么是机器学习？"}
    ]
    
    # 切换不同提供商
    provider = create_llm_provider(
        provider="deepseek",
        api_key="your-api-key",
        model="deepseek-chat"
    )
    
    response = provider.chat(messages)
    print(response)