# 示例：从记忆中搜索相关内容
results = hermes.memory.search("Python 异步编程", top_k=5)

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

pip install hermes-agent

git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
./setup-hermes.sh

export OPENROUTER_API_KEY=sk-or-v1-xxxx
hermes config set model openrouter/anthropic/claude-3.5-sonnet

export OPENAI_API_KEY=sk-xxxx
hermes config set model gpt-4-turbo

export NOUS_API_KEY=xxx
hermes config set model nous/<model-name>

export CUSTOM_API_KEY=xxx
hermes config set model custom/<model-name>
hermes config set api_base https://your-custom-endpoint.com/v1

export HF_TOKEN=hf-xxxx
hermes config set model huggingface/<model-id>

export TELEGRAM_BOT_TOKEN=123456:ABC-DEF
hermes config set platform telegram

hermes run

export DISCORD_BOT_TOKEN=xxxx.xxxx.xxxx
hermes config set platform discord

hermes run          # 启动 CLI 交互模式
hermes run --model  # 指定模型
hermes run --debug  # 调试模式

from hermes import Hermes

# 初始化
hermes = Hermes(
    model="openrouter/anthropic/claude-3.5-sonnet",
    api_key="sk-or-v1-xxxx"
)

# 单次对话
response = hermes.chat("解释一下什么是异步编程")
print(response)

# 带上下文的对话
hermes.add_message("user", "Python 如何处理并发？")
hermes.add_message("assistant", "Python 有多种并发方式...")
response = hermes.chat("有什么区别？")

# 执行工具
result = hermes.run_tool("bash", {"command": "ls -la"})
print(result)

# 管理技能
skills = hermes.list_skills()
print(skills)

# 搜索记忆
results = hermes.search_memory("异步编程最佳实践")

model:
  provider: openrouter
  name: anthropic/claude-3.5-sonnet

platform:
  enabled:
    - telegram
    - discord
    - cli
  default: telegram

skills:
  auto_create: true
  auto_improve: true
  storage_dir: ~/.hermes/skills

memory:
  retention_days: 90
  vector_store: sqlite

tools:
  timeout: 300
  max_calls: 100
  require_approval:
    - bash
    - write
    - delete

from hermes.tools import BaseTool, ToolResult
from typing import Dict, Any

class CompanyTool(BaseTool):
    """公司内部系统集成 Tool"""

    name = "company"
    description = "访问公司内部系统：日历、邮件、文档"

    def __init__(self, api_base: str, api_key: str):
        self.api_base = api_base
        self.api_key = api_key

    async def execute(self, action: str, **kwargs) -> ToolResult:
        """执行公司系统操作"""
        endpoints = {
            "calendar": f"{self.api_base}/calendar",
            "email": f"{self.api_base}/email",
            "docs": f"{self.api_base}/documents"
        }

        if action not in endpoints:
            return ToolResult(success=False, error=f"未知操作: {action}")

        # 实现具体的 API 调用逻辑
        response = await self._make_request(
            endpoints[action],
            kwargs
        )

        return ToolResult(success=True, data=response)

# 注册 Tool
hermes.register_tool(CompanyTool(
    api_base="https://api.company.com",
    api_key="xxx"
))

from hermes.skills import BaseSkill, SkillMetadata

class CodeReviewSkill(BaseSkill):
    """代码审查 Skill"""

    name = "code_review"
    description = "对代码进行安全性和性能审查"

    trigger_conditions = [
        "审查代码",
        "检查 bug",
        "代码审查"
    ]

    async def execute(self, context: Dict[str, Any]) -> Dict[str, Any]:
        code = context.get("code", "")
        language = context.get("language", "python")

        prompt = f"""请审查以下 {language} 代码，重点关注：
1. 安全性问题（SQL注入、XSS等）
2. 性能问题（N+1查询、内存泄漏等）
3. 代码规范（PEP8、最佳实践）

代码：
```{language}
{code}
```"""

        response = await hermes.llm.generate(prompt)

        return {
            "review": response,
            "issues": self._parse_issues(response),
            "score": self._calculate_score(response)
        }

# 注册 Skill
hermes.register_skill(CodeReviewSkill())

from hermes.learning import BaseLearningStrategy, Experience

class ConservativeLearningStrategy(BaseLearningStrategy):
    """保守学习策略：只学习高置信度的模式"""

    min_confidence = 0.9
    min_occurrences = 5

    async def should_learn(self, experience: Experience) -> bool:
        """判断是否应该学习这个经验"""
        # 必须满足多个条件
        if experience.confidence < self.min_confidence:
            return False

        if experience.occurrence_count < self.min_occurrences:
            return False

        # 必须是成功的经验
        if not experience.outcome.success:
            return False

        return True

    async def extract_skill(self, experience: Experience) -> Dict[str, Any]:
        """从经验中提取技能"""
        return {
            "name": f"auto_skill_{experience.id[:8]}",
            "description": experience.summary,
            "trigger": experience.trigger,
            "actions": experience.action_sequence,
            "confidence": experience.confidence,
            "source": "auto_learned"
        }

# 应用学习策略
hermes.set_learning_strategy(ConservativeLearningStrategy())