# 标准 Skill 接口示例
class SearchSkill:
    def __init__(self):
        self.name = "web_search"
        self.description = "搜索互联网获取实时信息"
    
    def run(self, query: str, num_results: int = 5) -> dict:
        """
        执行搜索
        
        Args:
            query: 搜索关键词
            num_results: 返回结果数量
            
        Returns:
            dict: 包含搜索结果的字典
        """
        # 执行搜索逻辑
        return {"results": [...]}

# 组合多个 Skill 完成复杂任务
workflow = [
    SearchSkill,      # 步骤1：搜索相关信息
    FileReadSkill,    # 步骤2：读取本地模板
    DataAnalysisSkill,# 步骤3：分析数据
    EmailSendSkill    # 步骤4：发送报告邮件
]

# 自定义 Skill 只需实现两个方法
class MyCustomSkill:
    def run(self, **kwargs):
        # 实现功能逻辑
        pass
    
    def get_schema(self):
        # 返回参数schema，供Agent理解
        return {...}

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain_openai import ChatOpenAI

# 初始化 LLM
llm = ChatOpenAI(temperature=0)

# 加载内置 Tools（Skills）
tools = load_tools([
    "serpapi",      # 搜索引擎
    "llm-math",     # 数学计算
    "wikipedia",    # 维基百科
    "terminal"      # 终端命令
], llm=llm)

# 创建 Agent
agent = initialize_agent(
    tools, 
    llm, 
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 使用 Agent 执行任务
result = agent.run("特斯拉今天的股价是多少？比昨天涨了多少百分比？")
print(result)

from langchain.tools import Tool
from langchain.agents import initialize_agent
import yfinance as yf

# 自定义股票查询 Skill
def get_stock_info(symbol: str) -> str:
    """获取股票实时信息"""
    stock = yf.Ticker(symbol)
    info = stock.info
    current_price = info.get('currentPrice', 'N/A')
    previous_close = info.get('previousClose', 'N/A')
    
    if current_price != 'N/A' and previous_close != 'N/A':
        change_pct = ((current_price - previous_close) / previous_close) * 100
        return f"当前价格: ${current_price}, 较昨日涨跌: {change_pct:.2f}%"
    return f"当前价格: ${current_price}"

# 封装为 LangChain Tool
stock_tool = Tool(
    name="stock_analyzer",
    func=get_stock_info,
    description="获取股票实时价格和涨跌幅，输入股票代码如TSLA、AAPL"
)

# 创建带自定义 Skill 的 Agent
agent = initialize_agent(
    [stock_tool], 
    llm, 
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)

# 执行分析
result = agent.run("分析特斯拉(TSLA)和苹果(AAPL)今天的股价表现，哪个更值得投资？")

from autogpt.agent import Agent
from autogpt.config import Config

# 加载配置
config = Config()

# 创建 Agent 实例
agent = Agent(
    ai_name="ResearchAssistant",
    ai_role="an AI that helps with market research",
    config=config
)

# 启动任务
agent.start_interaction_loop()

# 在 AutoGPT 中输入以下任务指令：
"""
任务：分析竞品公司的产品定价策略

步骤：
1. 搜索竞品公司官网
2. 访问产品定价页面
3. 提取各档位价格信息
4. 整理成表格保存到本地
5. 生成分析报告

约束：
- 只分析公开信息
- 保存结果到 ./reports/ 目录
"""

import openai
import json

# 定义函数（Skill）
functions = [
    {
        "name": "get_weather",
        "description": "获取指定城市的天气信息",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "城市名称，如北京、上海"
                },
                "date": {
                    "type": "string",
                    "description": "日期，格式YYYY-MM-DD，默认为今天"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "send_email",
        "description": "发送邮件",
        "parameters": {
            "type": "object",
            "properties": {
                "to": {"type": "string", "description": "收件人邮箱"},
                "subject": {"type": "string", "description": "邮件主题"},
                "content": {"type": "string", "description": "邮件内容"}
            },
            "required": ["to", "subject", "content"]
        }
    }
]

# 调用 OpenAI API
response = openai.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "查一下北京明天的天气，如果下雨就发邮件提醒我带伞"}
    ],
    functions=functions,
    function_call="auto"
)

# 处理函数调用
message = response.choices[0].message

if message.function_call:
    function_name = message.function_call.name
    function_args = json.loads(message.function_call.arguments)
    
    print(f"需要调用函数: {function_name}")
    print(f"参数: {function_args}")
    
    # 执行对应的 Skill 函数
    if function_name == "get_weather":
        result = get_weather(**function_args)
        print(f"天气查询结果: {result}")

import requests

def get_weather(city: str, date: str = None) -> str:
    """获取天气信息（示例实现）"""
    # 这里调用真实的天气 API
    api_key = "your_weather_api_key"
    url = f"https://api.weather.com/v1/current?city={city}&appid={api_key}"
    
    response = requests.get(url)
    data = response.json()
    
    weather = data.get("weather", "未知")
    temp = data.get("temperature", "N/A")
    
    return f"{city}天气：{weather}，温度{temp}°C"

def send_email(to: str, subject: str, content: str) -> str:
    """发送邮件（示例实现）"""
    # 这里调用邮件服务
    print(f"发送邮件到: {to}")
    print(f"主题: {subject}")
    print(f"内容: {content}")
    return "邮件发送成功"

# 多轮对话处理函数调用
def chat_with_functions(user_input: str):
    messages = [{"role": "user", "content": user_input}]
    
    while True:
        response = openai.chat.completions.create(
            model="gpt-4",
            messages=messages,
            functions=functions,
            function_call="auto"
        )
        
        message = response.choices[0].message
        messages.append(message)
        
        # 如果不需要调用函数，直接返回结果
        if not message.function_call:
            return message.content
        
        # 执行函数调用
        function_name = message.function_call.name
        function_args = json.loads(message.function_call.arguments)
        
        if function_name == "get_weather":
            result = get_weather(**function_args)
        elif function_name == "send_email":
            result = send_email(**function_args)
        else:
            result = "未知函数"
        
        # 将函数结果返回给模型
        messages.append({
            "role": "function",
            "name": function_name,
            "content": result
        })

# 使用
result = chat_with_functions("北京明天会下雨吗？如果下雨发邮件到test@example.com提醒我")
print(result)

import semantic_kernel as sk
from semantic_kernel.planning import BasicPlanner

# 初始化 Kernel
kernel = sk.Kernel()

# 添加 AI 服务
kernel.add_chat_service(
    "gpt4", 
    sk.openai.OpenAIChatCompletion("gpt-4", "your-api-key")
)

# 加载 Semantic Skill（自然语言定义）
summarize_skill = kernel.import_semantic_skill_from_directory(
    "./skills", "SummarizeSkill"
)

# 使用 Skill
summary = summarize_skill["Summarize"]("这是一段需要总结的长文本...")
print(summary)

from semantic_kernel.skill_definition import sk_function

class EmailSkill:
    """邮件操作 Skill"""
    
    @sk_function(
        description="发送邮件",
        name="send_email"
    )
    def send_email(self, to: str, subject: str, content: str) -> str:
        """发送邮件到指定地址"""
        # 实现邮件发送逻辑
        print(f"发送邮件到: {to}")
        print(f"主题: {subject}")
        return "邮件发送成功"
    
    @sk_function(
        description="查询收件箱",
        name="check_inbox"
    )
    def check_inbox(self, limit: int = 10) -> str:
        """查询最近的邮件"""
        # 实现查询逻辑
        return "您有3封未读邮件"

# 注册 Skill
email_skill = kernel.import_skill(EmailSkill(), "EmailSkill")

# 使用 Skill
result = email_skill["send_email"]("boss@company.com", "周报", "本周工作总结...")

from semantic_kernel.planning import BasicPlanner

# 定义多个 Skills
class CalendarSkill:
    @sk_function(description="查询日程")
    def get_schedule(self, date: str) -> str:
        # 查询日历 API
        return f"{date}的日程：上午9点会议，下午2点评审"

class EmailSkill:
    @sk_function(description="发送邮件")
    def send_email(self, to: str, subject: str, content: str) -> str:
        # 发送邮件
        return "邮件已发送"

# 注册 Skills
kernel.import_skill(CalendarSkill(), "CalendarSkill")
kernel.import_skill(EmailSkill(), "EmailSkill")

# 使用 Planner 自动组合 Skills
planner = BasicPlanner()

# 定义目标
goal = """
帮我查看明天的日程安排，
如果有会议，就发邮件给参会者准备材料
"""

# 生成执行计划
plan = planner.create_plan(goal, kernel)

# 执行计划
result = plan.invoke()
print(result)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.tools import QueryEngineTool, ToolMetadata

# 加载文档
documents = SimpleDirectoryReader("./data").load_data()

# 创建索引
index = VectorStoreIndex.from_documents(documents)

# 创建查询引擎
query_engine = index.as_query_engine()

# 封装为 Tool（Skill）
document_tool = QueryEngineTool(
    query_engine=query_engine,
    metadata=ToolMetadata(
        name="document_query",
        description="查询公司内部文档知识库"
    )
)

# 使用 Tool
response = document_tool.query("公司的年假政策是什么？")
print(response)

from llama_index.core.tools import FunctionTool
from llama_index.core.agent import ReActAgent
import requests

# 创建搜索引擎 Skill
def web_search(query: str) -> str:
    """搜索互联网获取最新信息"""
    # 调用搜索 API
    url = "https://api.serpapi.com/search"
    params = {
        "q": query,
        "api_key": "your_serpapi_key"
    }
    response = requests.get(url, params=params)
    results = response.json()
    return str(results.get("organic_results", []))

# 封装为 Tool
search_tool = FunctionTool.from_defaults(
    fn=web_search,
    name="web_search",
    description="搜索互联网获取最新信息"
)

# 创建文档查询 Tool（基于已有知识库）
documents = SimpleDirectoryReader("./research_papers").load_data()
index = VectorStoreIndex.from_documents(documents)
doc_tool = QueryEngineTool.from_defaults(
    query_engine=index.as_query_engine(),
    name="paper_query",
    description="查询已下载的研究论文"
)

# 创建 Agent，组合多个 Tools
agent = ReActAgent.from_tools(
    [search_tool, doc_tool],
    verbose=True
)

# 执行深度调研
response = agent.chat("""
帮我调研一下大语言模型在医疗领域的最新应用：
1. 先搜索最新的相关论文和新闻
2. 然后查看我们知识库中是否有相关研究
3. 总结当前的主要应用场景和技术挑战
""")

print(response)

# 未来可能的用法
agent.create_skill_from_description(
    "创建一个可以查询 GitHub 仓库星数的 Skill"
)
# AI 自动生成代码、测试、文档