11个AI智能代理框架大比拼：谁才是你的最佳选择？ 原创 精华

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())