from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool
from langchain_openai import ChatOpenAI

# 定义工具
def search_knowledge_base(query: str) -> str:
    """搜索知识库"""
    # 实现搜索逻辑
    return results

def get_order_info(order_id: str) -> str:
    """获取订单信息"""
    # 实现 API 调用
    return order_data

tools = [
    Tool(name="search_kb", func=search_knowledge_base, description="搜索知识库"),
    Tool(name="get_order", func=get_order_info, description="获取订单信息"),
]

# 创建 Agent
llm = ChatOpenAI(model="gpt-4")
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# 运行
result = executor.invoke({"input": "我的订单 #12345 什么时候到？"})

from crewai import Agent, Task, Crew

# 定义 Agent
researcher = Agent(
    role="知识库研究员",
    goal="准确回答用户的技术问题",
    backstory="你是一个经验丰富的技术支持专家",
    tools=[search_kb_tool],
    llm="gpt-4"
)

order_specialist = Agent(
    role="订单专员",
    goal="查询和处理订单相关问题",
    backstory="你是一个细心的订单处理专家",
    tools=[get_order_tool],
    llm="gpt-4"
)

manager = Agent(
    role="客服经理",
    goal="协调团队处理复杂投诉",
    backstory="你是一个经验丰富的客服经理",
    llm="gpt-4"
)

# 定义任务
research_task = Task(
    description="搜索知识库回答：{question}",
    agent=researcher,
    expected_output="知识库中的相关信息"
)

order_task = Task(
    description="查询订单 {order_id} 的状态",
    agent=order_specialist,
    expected_output="订单详细信息"
)

response_task = Task(
    description="根据收集的信息生成回复",
    agent=manager,
    expected_output="给用户的回复"
)

# 创建团队
crew = Crew(
    agents=[researcher, order_specialist, manager],
    tasks=[research_task, order_task, response_task],
    process="sequential"
)

# 运行
result = crew.kickoff(inputs={
    "question": "我的订单什么时候到？",
    "order_id": "12345"
})

from autogen import AssistantAgent, UserProxyAgent

# 创建 Agent
assistant = AssistantAgent(
    name="assistant",
    llm_config={"model": "gpt-4"},
    system_message="你是一个 AI 客服助手。"
)

order_agent = AssistantAgent(
    name="order_agent",
    llm_config={"model": "gpt-4"},
    system_message="你是订单查询专家。",
    code_execution_config=False
)

user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding"},
    is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE")
)

# 注册函数
@user_proxy.register_for_execution()
@order_agent.register_for_llm(name="get_order", description="获取订单信息")
def get_order(order_id: str) -> dict:
    # 实现 API 调用
    return {"status": "shipped", "eta": "2026-07-15"}

# 创建群组
groupchat = autogen.GroupChat(
    agents=[user_proxy, assistant, order_agent],
    messages=[],
    max_round=10
)

manager = autogen.GroupChatManager(groupchat=groupchat)

# 运行
user_proxy.initiate_chat(
    manager,
    message="我的订单 #12345 什么时候到？"
)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.agent import ReActAgent
from llama_index.core.tools import QueryEngineTool

# 加载知识库
documents = SimpleDirectoryReader("knowledge_base").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

# 创建工具
kb_tool = QueryEngineTool(
    query_engine=query_engine,
    metadata=ToolMetadata(
        name="knowledge_base",
        description="搜索产品知识库"
    )
)

# 创建 Agent
agent = ReActAgent.from_tools(
    [kb_tool, order_tool],
    llm=OpenAI(model="gpt-4"),
    verbose=True
)

# 运行
response = agent.chat("我的订单 #12345 什么时候到？")

import dspy

# 配置
lm = dspy.OpenAI(model="gpt-4")
dspy.settings.configure(lm=lm)

# 定义签名
class CustomerService(dspy.Signature):
    """AI 客服助手"""
    question = dspy.InputField(desc="用户问题")
    context = dspy.InputField(desc="相关知识库内容")
    order_info = dspy.InputField(desc="订单信息（如有）")
    answer = dspy.OutputField(desc="给用户的回复")

# 定义模块
class CustomerServiceAgent(dspy.Module):
    def __init__(self):
        self.retrieve = dspy.Retrieve(k=3)
        self.generate = dspy.ChainOfThought(CustomerService)
    
    def forward(self, question, order_id=None):
        # 检索知识库
        context = self.retrieve(question).passages
        
        # 获取订单信息
        order_info = get_order_info(order_id) if order_id else "无"
        
        # 生成回复
        result = self.generate(
            question=question,
            context=context,
            order_info=order_info
        )
        
        return result.answer

# 运行
agent = CustomerServiceAgent()
response = agent("我的订单什么时候到？", order_id="12345")

import dspy
from dspy.teleprompt import BootstrapFewShot

# 配置生产 LLM
lm = dspy.OpenAI(
    model="gpt-4",
    max_tokens=2000,
    temperature=0.1
)
dspy.settings.configure(lm=lm)

# 准备训练数据
trainset = [
    dspy.Example(
        question="退货政策是什么？",
        answer="我们提供 30 天无理由退货..."
    ).with_inputs("question"),
    # 更多样本...
]

# 优化 Agent
optimizer = BootstrapFewShot(metric=customer_service_metric)
optimized_agent = optimizer.compile(CustomerServiceAgent(), trainset=trainset)

# 保存优化后的 Agent
optimized_agent.save("production_agent.json")