from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain.tools.ddg_search import DuckDuckGoSearchRun
from langchain_openai import ChatOpenAI
# 定義代理可以使用的工具
search_tool = DuckDuckGoSearchRun()
tools = [
    Tool(
        name="Search",
        func=search_tool.run,
        descriptinotallow="用于搜索互聯網上最新信息"
    )
]
# 初始化語言模型
llm = ChatOpenAI(model="gpt-4")
# 使用React框架創建代理
agent = create_react_agent(llm, tools, "You are a helpful AI assistant.")
# 創建代理執行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 運行代理
response = agent_executor.invoke({"input": "AI智能代理框架的最新發展是什么？"})
print(response["output"])

import autogen
# 定義LLM配置
llm_config = {
    "config_list": [{"model": "gpt-4", "api_key": "your-api-key"}]
}
# 創建一個AssistantAgent
assistant = autogen.AssistantAgent(
    name="assistant",
    llm_cnotallow=llm_config,
    system_message="You are a helpful AI assistant."
)
# 創建一個UserProxyAgent
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="TERMINATE",  # 任務完成后自動回復TERMINATE
    max_consecutive_auto_reply=10,
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_cnotallow={"work_dir": "coding"}
)
# 初始化代理之間的聊天
user_proxy.initiate_chat(
    assistant,
    message="編寫一個用于計算斐波那契數列的Python函數。"
)

from crewai import Agent, Task, Crew
from langchain_openai import ChatOpenAI
# 初始化語言模型
llm = ChatOpenAI(model="gpt-4")
# 定義具有特定角色的代理
researcher = Agent(
    role="Research Analyst",
    goal="Discover and analyze the latest trends in AI technology",
    backstory="You are an expert in AI research with a keen eye for emerging trends",
    verbose=True,
    llm=llm
)
writer = Agent(
    role="Technical Writer",
    goal="Create comprehensive reports based on research findings",
    backstory="You are a skilled technical writer who can explain complex concepts clearly",
    verbose=True,
    llm=llm
)
# 為每個代理定義任務
research_task = Task(
    descriptinotallow="Research the latest developments in AI agent frameworks",
    expected_output="A comprehensive analysis of current AI agent frameworks",
    agent=researcher
)
writing_task = Task(
    descriptinotallow="Write a detailed report on AI agent frameworks based on the research",
    expected_output="A well-structured report on AI agent frameworks",
    agent=writer,
    cnotallow=[research_task]  # 寫作任務依賴于研究任務
)
# 使用代理和任務創建一個團隊
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True
)
# 執行團隊的任務
result = crew.kickoff()
print(result)

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
# 初始化內核
kernel = sk.Kernel()
# 添加OpenAI服務
api_key = "your-api-key"
model = "gpt-4"
kernel.add_chat_service("chat_completion", OpenAIChatCompletion(model, api_key))
# 使用自然語言創建一個語義函數
prompt = """
Generate a creative story about {{$input}}.
The story should be engaging and approximately 100 words.
"""
# 在內核中注冊該函數
story_function = kernel.create_semantic_function(prompt, max_tokens=500)
# 執行該函數
result = story_function("a robot learning to paint")
print(result)
# 使用Semantic Kernel創建一個簡單的代理
from semantic_kernel.planning import ActionPlanner
# 定義規劃器
planner = ActionPlanner(kernel)
# 執行一個計劃
plan = await planner.create_plan("Write a poem about artificial intelligence")
result = await plan.invoke()
print(result)

from typing import TypedDict, Annotated, Sequence
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
# 定義狀態結構
class AgentState(TypedDict):
    messages: Annotated[Sequence[HumanMessage | AIMessage], "對話中的消息"]
    next_step: Annotated[str, "下一步要采取的行動"]
# 初始化語言模型
llm = ChatOpenAI(model="gpt-4")
# 定義工作流中的節點（步驟）
def research(state: AgentState) -> AgentState:
    messages = state["messages"]
    response = llm.invoke(messages + [HumanMessage(cnotallow="Thoroughly research this topic.")])
    return {"messages": state["messages"] + [response], "next_step": "analyze"}
def analyze(state: AgentState) -> AgentState:
    messages = state["messages"]
    response = llm.invoke(messages + [HumanMessage(cnotallow="Analyze the research findings.")])
    return {"messages": state["messages"] + [response], "next_step": "conclude"}
def conclude(state: AgentState) -> AgentState:
    messages = state["messages"]
    response = llm.invoke(messages + [HumanMessage(cnotallow="Provide a conclusion based on the analysis.")])
    return {"messages": state["messages"] + [response], "next_step": "end"}
# 創建圖
workflow = StateGraph(AgentState)
# 添加節點
workflow.add_node("research", research)
workflow.add_node("analyze", analyze)
workflow.add_node("conclude", conclude)
# 添加邊
workflow.add_edge("research", "analyze")
workflow.add_edge("analyze", "conclude")
workflow.add_edge("conclude", END)
# 設置入口點
workflow.set_entry_point("research")
# 編譯圖
agent = workflow.compile()
# 執行工作流
result = agent.invoke({
    "messages": [HumanMessage(cnotallow="Tell me about AI agent frameworks")],
    "next_step": "research"
})
# 打印最終消息
for message in result["messages"]:
    print(f"{message.type}: {message.content}\n")

from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.core.tools import FunctionTool
from llama_index.llms.openai import OpenAI
# 定義一個簡單的工具函數
def search_documents(query: str) -> str:
    """在文檔數據庫中搜索信息。"""
    # 在實際應用中，這將查詢文檔存儲
    return f"Here are the search results for: {query}"
# 創建一個函數工具
search_tool = FunctionTool.from_defaults(
    name="search_documents",
    fn=search_documents,
    descriptinotallow="在文檔數據庫中搜索信息"
)
# 初始化語言模型
llm = OpenAI(model="gpt-4")
# 創建代理
agent = FunctionCallingAgentWorker.from_tools(
    [search_tool],
    llm=llm,
    verbose=True
)
# 運行代理
response = agent.chat("Find information about AI agent frameworks")
print(response)

from openai import OpenAI
import json
# 初始化OpenAI客戶端
client = OpenAI(api_key="your-api-key")
# 定義一個工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_weather",
            "description": "獲取給定位置的當前天氣",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市和州，例如，波士頓，MA"
                    }
                },
                "required": ["location"]
            }
        }
    }
]
# 處理天氣搜索工具的函數
def search_weather(location):
    # 在實際應用中，這將調用天氣API
    return f"The weather in {location} is currently sunny with a temperature of 72°F."
# 創建一個使用該工具的代理
messages = [{"role": "user", "content": "波士頓的天氣如何？"}]
response = client.chat.completions.create(
    model="gpt-4",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)
# 處理響應
response_message = response.choices[0].message
messages.append(response_message)
# 檢查模型是否想要調用一個函數
if response_message.tool_calls:
    # 處理每個工具調用
    for tool_call in response_message.tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        
        # 調用函數
        if function_name == "search_weather":
            function_response = search_weather(function_args.get("location"))
            
            # 將函數響應添加到消息中
            messages.append({
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": function_response
            })
    
    # 從模型中獲取新響應
    second_response = client.chat.completions.create(
        model="gpt-4",
        messages=messages
    )
    
    print(second_response.choices[0].message.content)
else:
    print(response_message.content)

from pydantic import BaseModel, Field
from typing import List
import os
# 這是一個基于Atomic Agents方法的簡化示例
# 在實際實現中，你將從atomic_agents包中導入
# 定義輸入/輸出模式
class ResearchQuery(BaseModel):
    topic: str = Field(descriptinotallow="要研究的主題")
    depth: int = Field(descriptinotallow="所需的研究深度（1-5）")
class ResearchResult(BaseModel):
    findings: List[str] = Field(descriptinotallow="研究的關鍵發現")
    sources: List[str] = Field(descriptinotallow="信息來源")
# 定義一個原子代理組件
class ResearchAgent:
    def __init__(self, api_key: str):
        self.api_key = api_key
        # 初始化任何必要的客戶端或工具
    
    def process(self, input_data: ResearchQuery) -> ResearchResult:
        # 在實際實現中，這將使用LLM進行研究
        print(f"正在研究 {input_data.topic}，深度為 {input_data.depth}")
        
        # 模擬研究結果
        findings = [
            f"關于 {input_data.topic} 的發現1",
            f"關于 {input_data.topic} 的發現2",
            f"關于 {input_data.topic} 的發現3"
        ]
        
        sources = [
            "https://github.com/e2b-dev/awesome-ai-agents",
            "https://github.com/e2b-dev/awesome-ai-agents"
        ]
        
        return ResearchResult(findings=findings, sources=sources)
# 使用示例
if __name__ == "__main__":
    # 創建代理
    agent = ResearchAgent(api_key=os.environ.get("OPENAI_API_KEY", "default-key"))
    
    # 創建輸入數據
    query = ResearchQuery(topic="AI代理框架", depth=3)
    
    # 處理查詢
    result = agent.process(query)
    
    # 顯示結果
    print("\n研究發現：")
    for i, finding in enumerate(result.findings, 1):
        print(f"{i}. {finding}")
    
    print("\n來源：")
    for source in result.sources:
        print(f"- {source}")

# Rasa項目結構示例
# 這通常會分散在Rasa項目的多個文件中
# domain.yml - 定義助手的領域
"""
version: "3.1"
intents:
  - greet
  - goodbye
  - ask_about_ai_frameworks
responses:
  utter_greet:
    - text: "Hello! How can I help you with AI frameworks today?"
  
  utter_goodbye:
    - text: "Goodbye! Feel free to ask about AI frameworks anytime."
  
  utter_about_frameworks:
    - text: "There are several popular AI agent frameworks including LangChain, AutoGen, CrewAI, and more. Which one would you like to know about?"
entities:
  - framework_name
slots:
  framework_name:
    type: text
    mappings:
    - type: from_entity
      entity: framework_name
"""
# data/nlu.yml - NLU的訓練數據
"""
version: "3.1"
nlu:
- intent: greet
  examples: |
    - hey
    - hello
    - hi
    - hello there
    - good morning
- intent: goodbye
  examples: |
    - bye
    - goodbye
    - see you around
    - see you later
- intent: ask_about_ai_frameworks
  examples: |
    - tell me about AI frameworks
    - what are the best AI agent frameworks
    - I need information about [LangChain](framework_name)
    - How does [AutoGen](framework_name) work?
    - Can you explain [CrewAI](framework_name)?
"""
# data/stories.yml - 對話管理的訓練數據
"""
version: "3.1"
stories:
- story: greet and ask about frameworks
  steps:
  - intent: greet
  - action: utter_greet
  - intent: ask_about_ai_frameworks
  - action: utter_about_frameworks
- story: ask about specific framework
  steps:
  - intent: ask_about_ai_frameworks
    entities:
    - framework_name: "LangChain"
  - action: action_framework_info
"""
# actions/actions.py - 自定義動作
"""
from typing import Any, Text, Dict, List
from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher
class ActionFrameworkInfo(Action):
    def name(self) -> Text:
        return "action_framework_info"
    def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
        
        framework = tracker.get_slot("framework_name")
        
        if framework.lower() == "langchain":
            dispatcher.utter_message(text="LangChain is an open-source framework for building applications using large language models.")
        elif framework.lower() == "autogen":
            dispatcher.utter_message(text="AutoGen is a framework from Microsoft Research that enables the development of LLM applications using multiple agents.")
        elif framework.lower() == "crewai":
            dispatcher.utter_message(text="CrewAI is a framework for orchestrating role-playing autonomous AI agents.")
        else:
            dispatcher.utter_message(text=f"I don't have specific information about {framework}, but it might be one of the emerging AI agent frameworks.")
            
        return []
"""
# 訓練并運行Rasa助手：
# rasa train
# rasa run

from metagpt.roles import (
 ProjectManager,
 ProductManager,
 Architect,
 Engineer
)
from metagpt.team import Team
import asyncio

async def main():
    # 定義項目需求
    requirement = "創建一個允許用戶搜索并比較AI代理框架的Web應用"
    
    # 創建具有不同角色的團隊成員
    product_manager = ProductManager()
    project_manager = ProjectManager()
    architect = Architect()
    engineer = Engineer()
    
    # 用這些角色組成一個團隊
    team = Team(
        name="AI Framework Explorer Team",
        members=[product_manager, project_manager, architect, engineer]
    )
    
    # 讓團隊開始處理需求
    await team.run(requirement)
    
    # 團隊將生成：
    # 1. PRD（產品需求文檔）
    # 2. 設計文檔
    # 3. 架構圖
    # 4. 實現代碼
    # 5. 測試
if __name__ == "__main__":
    asyncio.run(main())

from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.typing import ModelType
import asyncio
async def main():
    # 創建兩個具有不同角色的代理
    user_agent = ChatAgent(
        model_type=ModelType.GPT_4,
        system_message="You are a user who needs help analyzing data about AI frameworks."
    )
    
    assistant_agent = ChatAgent(
        model_type=ModelType.GPT_4,
        system_message="You are an AI assistant specialized in data analysis and AI frameworks."
    )
    
    # 用戶代理的初始消息
    user_message = BaseMessage.make_user_message(
        role_name="User",
        cnotallow="I need to compare different AI agent frameworks for my project. Can you help me analyze their features?"
    )
    
    # 開始對話
    assistant_response = await assistant_agent.step(user_message)
    print(f"Assistant: {assistant_response.content}\n")
    
    # 繼續對話
    for _ in range(3):  # 模擬對話的幾個回合
        user_response = await user_agent.step(assistant_response)
        print(f"User: {user_response.content}\n")
        
        assistant_response = await assistant_agent.step(user_response)
        print(f"Assistant: {assistant_response.content}\n")
if __name__ == "__main__":
    asyncio.run(main())