**🔥 开源界的核弹级项目！Fosowl/agenticSeek 让我看到了 AI Agent 的未来形态**

# 首先创建并激活虚拟环境
python -m venv agentic_env

# 在 Linux/Mac 上激活
source agentic_env/bin/activate

# 在 Windows 上激活
# agentic_env\Scripts\activate

# 使用 pip 安装 agenticSeek
pip install agenticSeek

# 如果你需要使用 OpenAI 的模型
pip install openai

# 如果你需要使用本地模型（如 Llama）
pip install transformers torch

# 可选：用于异步处理
pip install aiohttp asyncio

import agenticSeek

# 检查版本
print(f"agenticSeek 版本: {agenticSeek.__version__}")

# 列出可用的组件
print("可用的 Agent 类型:", agenticSeek.list_agent_types())
print("可用的工具:", agenticSeek.list_tools())

# config.yaml 示例配置

# LLM 配置
llm:
  provider: "openai"  # 可选: openai, anthropic, local
  model: "gpt-4"
  api_key: "${OPENAI_API_KEY}"  # 使用环境变量

# Agent 配置
agent:
  max_iterations: 10
  timeout: 300
  verbose: true

# 搜索工具配置
tools:
  search:
    enabled: true
    default_engine: "duckduckgo"  # 可选: google, bing, duckduckgo

# 导入核心组件
from agenticSeek import Agent, Message, ToolRegistry

# 创建一个简单的 Agent 实例
def create_basic_agent():
    """
    创建基础 Agent 的标准流程
    """
    # 初始化工具注册表
    tools = ToolRegistry()

    # 注册我们需要的工具
    tools.register("search", search_tool)
    tools.register("calculator", calculator_tool)
    tools.register("web_fetch", web_fetch_tool)

    # 创建 Agent 实例
    agent = Agent(
        name="ResearchAssistant",
        tools=tools,
        system_prompt="""
        你是一个专业的研究助手。你的职责是：
        1. 理解用户的问题
        2. 决定是否需要搜索外部信息
        3. 综合多个来源的信息给出完整答案
        4. 始终保持回答的准确性和可验证性
        """
    )

    return agent

# 简单的搜索工具示例
def search_tool(query: str) -> str:
    """
    模拟搜索功能
    在实际使用中，这会调用真实的搜索引擎
    """
    # 这里是简化示例
    results = [
        {"title": "相关结果1", "snippet": "这是第一个搜索结果的内容摘要..."},
        {"title": "相关结果2", "snippet": "这是第二个搜索结果的内容摘要..."},
    ]
    return str(results)

from agenticSeek import tool, ToolBuilder

# 方法一：使用装饰器注册工具
@tool(name="天气查询", description="查询指定城市的天气情况")
def get_weather(city: str) -> str:
    """
    获取城市天气信息

    参数:
        city: 城市名称，例如 "北京"、"上海"

    返回:
        天气情况的描述字符串
    """
    # 实际实现中会调用天气 API
    return f"{city}今天晴转多云，温度15-22度，适宜外出"

# 方法二：使用 ToolBuilder 构建复杂工具
def create_custom_search_tool():
    """
    创建一个带有参数验证和错误处理的搜索工具
    """
    return ToolBuilder(
        name="高级搜索",
        description="执行网络搜索并返回结构化结果",
        func=custom_search_impl,
        parameters={
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "搜索关键词",
                    "min_length": 2
                },
                "limit": {
                    "type": "integer",
                    "description": "返回结果数量",
                    "default": 10,
                    "minimum": 1,
                    "maximum": 50
                },
                "engine": {
                    "type": "string",
                    "description": "搜索引擎选择",
                    "enum": ["google", "bing", "duckduckgo"]
                }
            },
            "required": ["query"]
        }
    ).build()

def custom_search_impl(query: str, limit: int = 10, engine: str = "duckduckgo"):
    """
    自定义搜索实现
    """
    # 这里是你的搜索逻辑
    results = []
    # ... 搜索实现代码 ...
    return results

from agenticSeek import Memory, VectorMemory

# 基础内存使用
def basic_memory_usage():
    """
    基础内存操作的演示
    """
    memory = Memory()

    # 添加记忆
    memory.add(
        content="用户正在开发一个电商推荐系统",
        importance=0.8,
        tags=["项目", "电商", "推荐系统"]
    )

    memory.add(
        content="用户偏好使用 Python 和 FastAPI",
        importance=0.9,
        tags=["技术栈", "偏好"]
    )

    # 检索相关记忆
    related = memory.retrieve("用户的技术背景是什么？")
    print("检索到的记忆:", related)

    # 查看所有记忆
    all_memories = memory.get_all()
    print(f"总共有 {len(all_memories)} 条记忆")

    return memory

# 向量内存（支持语义搜索）
def vector_memory_demo():
    """
    使用向量内存实现语义级别的记忆检索
    """
    # 初始化向量内存
    memory = VectorMemory(
        embedding_model="text-embedding-ada-002",
        dimension=1536
    )

    # 添加大量记忆
    memories = [
        "用户在上周完成了用户认证模块的开发",
        "项目使用了 PostgreSQL 作为主数据库",
        "Redis 用于缓存会话数据",
        "前端采用 React 框架开发",
        "团队计划下个月开始测试支付模块"
    ]

    for mem in memories:
        memory.add(mem)

    # 语义搜索示例
    # 即使不包含 "数据库" 这个词，也能找到相关记忆
    results = memory.semantic_search(
        query="我们用什么存储数据？",
        top_k=3
    )

    for result in results:
        print(f"相似度: {result['score']:.3f}")
        print(f"内容: {result['content']}")

    return memory

from agenticSeek import Planner, Task

def planning_demo():
    """
    演示如何使用规划器处理复杂任务
    """
    planner = Planner(
        mode=" stepwise",  # 逐步规划模式
        max_depth=5
    )

    # 定义一个复杂任务
    complex_task = """
    帮助用户完成一个市场调研报告，需要：
    1. 收集目标竞品的基本信息
    2. 分析各竞品的定价策略
    3. 整理用户评价和反馈
    4. 总结市场趋势和机会点
    5. 给出产品定位建议
    """

    # 生成执行计划
    plan = planner.create_plan(complex_task)

    # 查看生成的计划
    print("=" * 50)
    print("执行计划预览")
    print("=" * 50)

    for i, step in enumerate(plan.steps, 1):
        print(f"\n步骤 {i}: {step.description}")
        print(f"  预期工具: {step.required_tools}")
        print(f"  依赖步骤: {step.dependencies}")

    return plan

"""
AI 研究助手 - agenticSeek 实战项目

这个助手能够自动完成复杂的市场调研任务
"""

import os
from agenticSeek import Agent, ToolRegistry, VectorMemory, Planner
from agenticSeek.tools import SearchTool, WebFetchTool

# 设置 API 密钥
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# === 自定义工具定义 ===

def fact_check_tool(claim: str, sources: list) -> dict:
    """
    事实核查工具

    参数:
        claim: 需要核查的声明
        sources: 声明来源列表

    返回:
        包含核查结果的字典
    """
    # 简化实现
    result = {
        "claim": claim,
        "verdict": "待验证",
        "confidence": 0.0,
        "issues": []
    }

    # 实际应用中，这里会调用专门的 fact-check API
    return result

def report_formatter(data: dict, format_type: str = "markdown") -> str:
    """
    报告格式化工具

    参数:
        data: 报告数据
        format_type: 输出格式 (markdown/html/pdf)

    返回:
        格式化后的报告文本
    """
    if format_type == "markdown":
        output = "# 研究报告\n\n"
        output += f"**主题**: {data.get('topic', 'N/A')}\n\n"
        output += "## 摘要\n\n"
        output += f"{data.get('summary', '')}\n\n"
        output += "## 详细分析\n\n"

        for section in data.get('sections', []):
            output += f"### {section['title']}\n\n"
            output += f"{section['content']}\n\n"

        output += "## 结论\n\n"
        output += f"{data.get('conclusion', '')}\n\n"
        output += "---\n"
        output += "*报告生成时间: " + data.get('timestamp', '') + "*\n"

        return output

    return str(data)

# === 构建研究助手 Agent ===

def build_research_assistant():
    """
    构建完整的研究助手 Agent
    """
    # 创建工具注册表
    tools = ToolRegistry()

    # 注册内置工具
    tools.register("search", SearchTool(
        engines=["duckduckgo", "bing"],
        max_results=10
    ))
    tools.register("fetch", WebFetchTool(
        timeout=30,
        user_agent="ResearchAssistant/1.0"
    ))

    # 注册自定义工具
    tools.register("fact_check", fact_check_tool)
    tools.register("format_report", report_formatter)

    # 创建记忆系统
    memory = VectorMemory(
        embedding_model="text-embedding-ada-002"
    )

    # 创建规划器
    planner = Planner(
        mode="replan",  # 支持动态调整计划
        max_iterations=15
    )

    # 定义系统提示词
    system_prompt = """
    你是一个专业的研究助手，专门帮助用户进行深度市场调研和竞品分析。

    你的工作流程：

    1. **问题理解阶段**
       - 仔细分析用户的研究目标
       - 识别关键信息需求
       - 确定研究的边界和范围

    2. **信息收集阶段**
       - 制定信息收集计划
       - 执行多轮搜索获取相关信息
       - 验证信息的可靠性和时效性

    3. **分析整理阶段**
       - 整理收集到的信息
       - 识别关键洞察和模式
       - 交叉验证不同来源的信息

    4. **报告生成阶段**
       - 结构化输出研究报告
       - 明确标注信息来源
       - 提供可操作的建议

    重要原则：
    - 始终基于可靠来源
    - 对不确定的信息保持谨慎
    - 主动识别信息缺口
    - 用清晰的结构呈现复杂信息
    """

    # 创建 Agent
    assistant = Agent(
        name="ResearchAssistant",
        tools=tools,
        memory=memory,
        planner=planner,
        system_prompt=system_prompt,
        config={
            "verbose": True,
            "temperature": 0.7,
            "max_tokens": 4000
        }
    )

    return assistant

# === 主业务逻辑 ===

class ResearchSession:
    """
    研究会话管理器
    负责管理整个研究流程的状态和进度
    """

    def __init__(self, assistant: Agent):
        self.assistant = assistant
        self.research_data = {
            "topic": "",
            "findings": [],
            "sources": [],
            "timeline": []
        }

    def start_research(self, topic: str, requirements: str = ""):
        """
        开始一个新的研究项目

        参数:
            topic: 研究主题
            requirements: 用户的特殊需求或关注点
        """
        print("=" * 60)
        print("🚀 开始研究项目")
        print("=" * 60)
        print(f"📌 主题: {topic}")
        print(f"📋 需求: {requirements or '无特殊要求'}")
        print("-" * 60)

        self.research_data["topic"] = topic

        # 构建研究提示
        prompt = self._build_research_prompt(topic, requirements)

        # 执行研究
        result = self.assistant.run(prompt)

        return result

    def _build_research_prompt(self, topic: str, requirements: str) -> str:
        """
        构建详细的研究提示
        """
        prompt = f"""
        请帮我对「{topic}」进行深入研究。

        具体要求：
        {requirements if requirements else "请进行全面的基础调研，包括定义、现状、主要参与者、发展趋势等。"}

        研究完成后，请输出：
        1. 研究摘要（200字以内）
        2. 关键发现（至少5个）
        3. 详细分析（按主题分类）
        4. 数据来源说明
        5. 进一步研究的建议

        请确保所有观点都有对应的信息来源支持。
        """
        return prompt

    def add_findings(self, finding: dict):
        """
        添加研究发现
        """
        self.research_data["findings"].append(finding)
        print(f"✅ 新发现已添加: {finding.get('title', 'N/A')}")

    def generate_report(self, output_format: str = "markdown") -> str:
        """
        生成最终研究报告
        """
        report_data = {
            "topic": self.research_data["topic"],
            "summary": self._generate_summary(),
            "sections": self._generate_sections(),
            "conclusion": self._generate_conclusion(),
            "timestamp": self._get_timestamp()
        }

        report = report_formatter(report_data, output_format)

        # 保存到记忆
        self.assistant.memory.add(
            f"研究报告: {self.research_data['topic']}",
            importance=0.95
        )

        return report

    def _generate_summary(self) -> str:
        """生成摘要"""
        findings = self.research_data["findings"]
        if not findings:
            return "暂无研究发现"
        return f"本研究共收集了 {len(findings)} 项重要发现。"

    def _generate_sections(self) -> list:
        """生成报告章节"""
        return [
            {
                "title": "研究背景",
                "content": f"本报告针对「{self.research_data['topic']}」进行深入分析。"
            },
            {
                "title": "主要发现",
                "content": "\n".join([
                    f"- {f.get('title', 'N/A')}: {f.get('description', '')}"
                    for f in self.research_data["findings"][:5]
                ])
            }
        ]

    def _generate_conclusion(self) -> str:
        """生成结论"""
        return "基于以上研究，建议持续关注该领域的发展动态。"

    def _get_timestamp(self) -> str:
        """获取时间戳"""
        from datetime import datetime
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# === 运行演示 ===

def main():
    """
    主函数 - 运行完整演示
    """
    print("正在初始化研究助手...")

    # 构建助手
    assistant = build_research_assistant()

    # 创建研究会话
    session = ResearchSession(assistant)

    # 定义研究主题
    topic = "2024年人工智能在教育行业的应用趋势"
    requirements = """
    重点关注：
    1. 个性化学习平台的发展
    2. AI 辅导老师的现状和前景
    3. 教育公平性问题
    4. 主要厂商和产品分析
    """

    # 启动研究
    result = session.start_research(topic, requirements)

    # 模拟添加一些研究发现（实际使用中，这些会从 Agent 获取）
    session.add_findings({
        "title": "个性化学习成为主流",
        "description": "超过70%的教育科技公司正在开发AI驱动的个性化学习系统",
        "source": "EdTech Weekly Report 2024"
    })

    session.add_findings({
        "title": "生成式AI的广泛应用",
        "description": "ChatGPT类技术正在被整合到教学平台中",
        "source": "Gartner Hype Cycle"
    })

    # 生成报告
    print("\n" + "=" * 60)
    print("📄 生成研究报告")
    print("=" * 60 + "\n")

    report = session.generate_report("markdown")
    print(report)

    # 导出报告
    with open("research_report.md", "w", encoding="utf-8") as f:
        f.write(report)

    print("\n✅ 报告已保存到 research_report.md")

# 运行入口
if __name__ == "__main__":
    main()

# === 预期输出示例 ===

正在初始化研究助手...
正在构建工具系统...
Agent 初始化完成 ✓

============================================================
🚀 开始研究项目
============================================================
📌 主题: 2024年人工智能在教育行业的应用趋势
📋 需求: 重点关注：1. 个性化学习...（省略）
------------------------------------------------------------
[Agent] 正在分析研究需求...
[Agent] 制定信息收集计划...
[Agent] 执行搜索: "AI education trends 2024"
[Agent] 执行搜索: "personalized learning platforms"
[Agent] 验证信息可靠性...
[Agent] 综合分析完成...

✅ 新发现已添加: 个性化学习成为主流
✅ 新发现已添加: 生成式AI的广泛应用

============================================================
📄 生成研究报告
============================================================

# 研究报告

**主题**: 2024年人工智能在教育行业的应用趋势

## 摘要

本研究共收集了 2 项重要发现。

## 详细分析

### 研究背景

本报告针对「2024年人工智能在教育行业的应用趋势」进行深入分析。

### 主要发现

- 个性化学习成为主流: 超过70%的教育科技公司正在开发AI驱动的个性化学习系统
- 生成式AI的广泛应用: ChatGPT类技术正在被整合到教学平台中

## 结论

基于以上研究，建议持续关注该领域的发展动态。

---
*报告生成时间: 2024-01-15 14:30:00*

✅ 报告已保存到 research_report.md

# 构建智能客服 Agent

def build_customer_service_agent():
    """
    构建具备主动服务能力的智能客服
    """
    from agenticSeek import Agent, ToolRegistry
    from agenticSeek.tools import KnowledgeBaseTool, TicketTool

    tools = ToolRegistry()

    # 知识库查询
    tools.register("kb_search", KnowledgeBaseTool(
        index_path="./knowledge_base",
        similarity_threshold=0.75
    ))

    # 工单处理
    tools.register("create_ticket", TicketTool(
        auto_assign=True
    ))

    # 情感分析（自定义工具）
    def sentiment_analysis(text: str) -> dict:
        """
        分析用户情感的极性和强度
        """
        # 实际应用中会使用专门的情感分析模型
        return {
            "sentiment": "negative" if "不满意" in text else "positive",
            "urgency": "high" if any(kw in text for kw in ["紧急", "马上", "立即"]) else "normal"
        }

    tools.register("sentiment", sentiment_analysis)

    agent = Agent(
        name="SmartCS",
        tools=tools,
        system_prompt="""
        你是一个专业的智能客服代表。

        工作原则：
        1. 首先理解用户的问题和情绪状态
        2. 积极倾听，不要打断用户
        3. 在知识库中寻找相关解决方案
        4. 如果问题复杂，主动创建工单并告知用户处理时限
        5. 保持耐心和同理心

        特别注意：
        - 当检测到负面情绪时，要更加耐心和理解
        - 对于紧急问题，要优先处理
        - 无法解答时，诚实告知用户并升级处理
        """
    )

    return agent

# 使用示例
def customer_service_example():
    agent = build_customer_service_agent()

    user_message = "我已经等了3天了！我的订单号是 #12345，什么时候能发货？"

    response = agent.handle(
        user_id="user_001",
        message=user_message,
        context={"order_history": [...]}
    )

    print(f"用户情绪: {response['sentiment']}")
    print(f"推荐回复: {response['message']}")
    print(f"执行的操作: {response['actions']}")

# 构建代码审查 Agent

from agenticSeek import Agent, ToolRegistry

def build_code_review_agent():
    """
    构建自动化代码审查助手
    """
    tools = ToolRegistry()

    def code_analyzer(code: str, language: str) -> dict:
        """
        静态代码分析
        """
        return {
            "complexity": "medium",
            "issues": [
                {"type": "warning", "line": 42, "message": "长函数建议拆分"},
                {"type": "info", "line": 65, "message": "可考虑使用列表推导式"}
            ],
            "suggestions": ["添加类型注解", "增加单元测试"]
        }

    def security_scanner(code: str) -> dict:
        """
        安全漏洞扫描
        """
        return {
            "vulnerabilities": [],
            "risk_level": "low",
            "recommendations": ["建议添加输入验证"]
        }

    def style_checker(code: str, language: str) -> dict:
        """
        代码风格检查
        """
        return {
            "violations": [
                {"line": 10, "rule": "E501", "message": "行过长（85字符）"}
            ],
            "score": 9.5
        }

    tools.register("analyze", code_analyzer)
    tools.register("security_scan", security_scanner)
    tools.register("style_check", style_checker)

    agent = Agent(
        name="CodeReviewer",
        tools=tools,
        system_prompt="""
        你是一个专业的代码审查助手。

        审查维度：
        1. 代码质量：可读性、可维护性、复杂度
        2. 安全性：潜在漏洞、风险点
        3. 性能：效率问题、优化空间
        4. 最佳实践：是否符合语言/框架规范

        输出要求：
        - 明确标注问题严重程度
        - 提供具体的修改建议
        - 给出问题代码和推荐代码的对比
        """
    )

    return agent

# 构建个人知识管理助手

from agenticSeek import Agent, VectorMemory

def build_personal_knowledge_assistant():
    """
    构建个人知识管理和问答助手
    """
    # 创建向量记忆
    memory = VectorMemory(
        embedding_model="text-embedding-ada-002"
    )

    # 加载个人知识库
    def load_documents(doc_paths: list):
        """
        批量加载文档到知识库
        """
        for path in doc_paths:
            with open(path, 'r', encoding='utf-8') as f:
                content = f.read()
                memory.add(
                    content=content,
                    metadata={"source": path}
                )
        print(f"已加载 {len(doc_paths)} 个文档")

    def semantic_search_with_context(query: str, top_k: int = 5):
        """
        语义搜索并返回上下文
        """
        results = memory.semantic_search(query, top_k=top_k)

        # 构建上下文
        context = "\n\n".join([
            f"[来源 {i+1}] {r['content']}"
            for i, r in enumerate(results)
        ])

        return {
            "query": query,
            "context": context,
            "references": [
                {"content": r["content"][:100], "score": r["score"]}
                for r in results
            ]
        }

    tools = ToolRegistry()
    tools.register("search_kb", semantic_search_with_context)
    tools.register("load_docs", load_documents)

    agent = Agent(
        name="KnowledgeBot",
        tools=tools,
        memory=memory,
        system_prompt="""
        你是一个个人知识助手，基于用户自己的文档和笔记回答问题。

        使用原则：
        1. 优先使用知识库中的信息回答
        2. 如果信息不足以回答，明确告知用户
        3. 标注信息来源，帮助用户追溯
        4. 可以跨文档综合信息
        """
    )

    return agent

# 决策优化配置

def optimize_agent_decisions():
    """
    通过配置提升 Agent 的决策质量
    """
    agent = Agent(
        name="OptimizedAgent",
        config={
            # 推理相关配置
            "reasoning_depth": 3,  # 增加推理深度
            "self_correction": True,  # 启用自我纠错

            # 工具使用配置
            "tool_selection_strategy": "adaptive",  # 自适应策略
            "max_tool_calls_per_turn": 5,

            # 输出控制
            "explain_reasoning": True,  # 解释推理过程
            "confidence_threshold": 0.7,  # 置信度阈值
        }
    )

    return agent

# 使用 Chain of Thought 提示优化推理
def cot_optimization():
    """
    使用思维链提示增强推理能力
    """
    agent = Agent(
        name="CoTAgent",
        system_prompt="""
        在做出任何决定之前，请遵循以下思维链：

        1. **问题理解**：我需要理解用户的真正需求是什么？

        2. **信息评估**：我需要哪些信息？当前是否已经足够？

        3. **方案生成**：有哪些可能的解决方案？各自的优缺点是什么？

        4. **风险评估**：每个方案的风险点在哪里？

        5. **最终决策**：基于以上分析，我的推荐是什么？为什么？

        请在回复中展示你的思考过程。
        """
    )

from agenticSeek import MultiAgent, AgentPool

def multi_agent_collaboration():
    """
    构建多 Agent 协作系统
    """
    # 创建 Agent 池
    pool = AgentPool()

    # 注册不同专长的 Agent
    pool.register(
        name="researcher",
        agent_type="research",
        system_prompt="你专注于信息收集和初步分析"
    )

    pool.register(
        name="analyst",
        agent_type="analysis",
        system_prompt="你擅长深入分析和发现洞察"
    )

    pool.register(
        name="writer",
        agent_type="writing",
        system_prompt="你擅长将复杂信息整理成清晰的文档"
    )

    # 创建多 Agent 协作系统
    collaboration = MultiAgent(
        pool=pool,
        coordination_mode="sequential",  # 或 "parallel"
        result_aggregator="summarize"
    )

    # 执行协作任务
    result = collaboration.execute(
        task="分析 AI 在医疗行业的应用机会",
        workflow=[
            {"agent": "researcher", "task": "收集 AI 医疗应用的相关信息"},
            {"agent": "analyst", "task": "分析市场机会和挑战"},
            {"agent": "writer", "task": "撰写分析报告"}
        ]
    )

    return result

from agenticSeek import Memory, PriorityMemory

def memory_best_practices():
    """
    高效使用记忆系统的最佳实践
    """

    # 1. 定期压缩记忆，防止无限增长
    def periodic_compression(memory: Memory, threshold: int = 1000):
        """
        当记忆超过阈值时执行压缩
        """
        if len(memory) > threshold:
            # 保留最重要的记忆
            important = memory.get_by_importance(min_score=0.8)
            # 合并相似记忆
            merged = memory.consolidate(similarity_threshold=0.9)
            return merged
        return memory

    # 2. 基于优先级的记忆管理
    priority_memory = PriorityMemory(
        tiers=["short_term", "long_term", "persistent"],
        retention_policy={
            "short_term": {"max_items": 100, "ttl": 3600},
            "long_term": {"max_items": 500, "ttl": 86400 * 7},
            "persistent": {"max_items": 1000, "ttl": None}
        }
    )

    # 3. 记忆索引优化
    def optimize_memory_index(memory: VectorMemory):
        """
        定期优化向量索引，提升检索效率
        """
        memory.rebuild_index(
            batch_size=100,
            optimizers=["hnsw"],
            params={"ef_construction": 200, "M": 16}
        )
        print("索引优化完成")

    return priority_memory

from agenticSeek import Agent, RetryPolicy, ErrorHandler

def robust_error_handling():
    """
    构建健壮的错误处理系统
    """

    # 定义重试策略
    retry_policy = RetryPolicy(
        max_attempts=3,
        backoff_type="exponential",  # 指数退避
        base_delay=1,  # 基础延迟（秒）
        max_delay=60,
        retryable_errors=[
            "rate_limit",
            "timeout",
            "connection_error"
        ]
    )

    # 定义错误处理器
    error_handler = ErrorHandler(
        handlers={
            "rate_limit": lambda e: {
                "action": "wait_and_retry",
                "wait_time": e.retry_after if hasattr(e, 'retry_after') else 60
            },
            "invalid_input": lambda e: {
                "action": "clarify",
                "message": "请提供更明确的信息"
            },
            "tool_failure": lambda e: {
                "action": "fallback",
                "fallback_tool": "basic_search"
            }
        }
    )

    # 创建具备容错能力的 Agent
    agent = Agent(
        name="RobustAgent",
        retry_policy=retry_policy,
        error_handler=error_handler,
        fallback_response="抱歉，我暂时无法处理这个请求。请稍后再试或换个方式描述您的问题。"
    )

    return agent

def performance_optimization():
    """
    提升 agenticSeek 应用性能的建议
    """

    # 1. 批量处理
    def batch_processing(requests: list, batch_size: int = 10):
        """
        批量处理请求以提高吞吐量
        """
        results = []
        for i in range(0, len(requests), batch_size):
            batch = requests[i:i + batch_size]
            batch_results = process_batch(batch)
            results.extend(batch_results)
        return results

    # 2. 缓存策略
    def smart_caching(agent: Agent):
        """
        实现智能缓存减少重复计算
        """
        from functools import lru_cache

        @lru_cache(maxsize=1000)
        def cached_search(query_hash: str, *args):
            # 基于查询哈希的缓存
            return agent.search(query_hash)

        return cached_search

    # 3. 异步执行
    async def async_agent_execution():
        """
        使用异步方式提高并发处理能力
        """
        import asyncio
        from agenticSeek import AsyncAgent

        agent = AsyncAgent()

        # 同时执行多个任务
        tasks = [
            agent.arun("任务1"),
            agent.arun("任务2"),
            agent.arun("任务3")
        ]

        results = await asyncio.gather(*tasks)
        return results

    return {
        "batch_processing": batch_processing,
        "smart_caching": smart_caching,
        "async_agent_execution": async_agent_execution
    }

# === 快速参考 ===

# 安装
pip install agenticSeek

# 导入核心组件
from agenticSeek import Agent, ToolRegistry, Memory, VectorMemory

# 创建基础 Agent
agent = Agent(name="MyAgent", tools=ToolRegistry())

# 注册工具
tools = ToolRegistry()
tools.register("search", search_function)

# 使用记忆
memory = VectorMemory()
memory.add("内容")
results = memory.semantic_search("查询")

# 执行任务
result = agent.run("用户输入")