travel-agent-cli 0.2.0 → 0.2.1

package/bin/cli.js

@@ -11,8 +11,8 @@ const fs = require('fs');
 
 // 获取包的安装路径
 const packagePath = path.join(__dirname, '..');
-const projectRoot = path.join(packagePath, '..');
-const mainPy = path.join(projectRoot, 'main.py');
+const pythonDir = path.join(packagePath, 'python');
+const mainPy = path.join(pythonDir, 'main.py');
 
 // 检查 Python 是否可用
 function findPython() {
@@ -34,9 +34,9 @@ function findPython() {
 // 检查虚拟环境是否存在
 function getVenvPython() {
   const venvPaths = [
-    path.join(projectRoot, 'venv', 'bin', 'python'),
-    path.join(projectRoot, '.venv', 'bin', 'python'),
-    path.join(projectRoot, 'venv', 'Scripts', 'python.exe'),
+    path.join(pythonDir, 'venv', 'bin', 'python'),
+    path.join(pythonDir, '.venv', 'bin', 'python'),
+    path.join(pythonDir, 'venv', 'Scripts', 'python.exe'),
   ];
 
   for (const venvPath of venvPaths) {
@@ -118,7 +118,7 @@ function run() {
   const pyArgs = [mainPy, ...args];
   const child = spawn(pythonCmd, pyArgs, {
     stdio: 'inherit',
-    cwd: projectRoot
+    cwd: pythonDir
   });
 
   child.on('error', (err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "travel-agent-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "AI 驱动的旅行目的地推荐 Agent - 命令行工具（集成 FlyAI 旅行搜索）",
   "bin": {
     "travel-agent": "bin/cli.js",
@@ -28,7 +28,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-username/travel-agent.git",
+    "url": "git+https://github.com/your-username/travel-agent.git",
     "directory": "npm-package"
   },
   "engines": {

package/python/agents/__init__.py

@@ -0,0 +1,19 @@
+"""Agents 模块 - 多 Agent 系统
+
+导出所有 Agent 类
+"""
+from agents.base import BaseAgent
+from agents.collector_agent import CollectionAgent
+from agents.analysis_agent import AnalysisAgent
+from agents.planning_agent import PlanningAgent
+from agents.report_agent import ReportAgent
+from agents.manager_agent import ManagerAgent
+
+__all__ = [
+    "BaseAgent",
+    "CollectionAgent",
+    "AnalysisAgent",
+    "PlanningAgent",
+    "ReportAgent",
+    "ManagerAgent",
+]

package/python/agents/analysis_agent.py

@@ -0,0 +1,234 @@
+"""分析 Agent - 负责数据分析和目的地排序"""
+from typing import Dict, Any, List, Optional
+import json
+from agents.base import BaseAgent
+from analyzers.hot_score import HotScoreCalculator
+from config.models import SocialPost, WenlvInfo
+
+
+class AnalysisAgent(BaseAgent):
+    """分析 Agent
+
+    职责：
+    - 计算目的地热度评分
+    - 综合分析并排序
+    - 生成推荐理由
+    """
+
+    name = "analysis_agent"
+    role = "旅行数据分析师"
+    goal = "分析采集的数据，识别热门目的地，给出专业评分和推荐理由"
+
+    def __init__(
+        self,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        use_tools: bool = False,
+    ):
+        super().__init__(provider, model, use_tools)
+        self.score_calculator = HotScoreCalculator()
+
+    async def execute_local(self, task: str, context: Dict[str, Any]) -> str:
+        """本地执行分析"""
+        posts = context.get("posts", [])
+        wenlv_infos = context.get("wenlv_infos", [])
+        analysis = context.get("analysis", {})
+
+        # 如果有分析数据，生成本地推荐
+        if analysis:
+            destinations = analysis.get("destinations", [])
+            top_n = 10
+
+            recommendations = []
+            for i, dest in enumerate(destinations[:top_n], 1):
+                recommendations.append({
+                    "name": dest.get("name", "未知目的地"),
+                    "rank": i,
+                    "score": dest.get("scores", {}).get("total_score", 5.0),
+                    "reason": f"基于 {dest.get('post_count', 0)} 条社交媒体内容和 {dest.get('wenlv_count', 0)} 条文旅信息推荐",
+                    "estimated_cost": "¥3000-5000",
+                    "suggested_days": 5,
+                    "best_time": "春秋季节",
+                    "highlights": ["特色美食", "文化体验", "自然风光"]
+                })
+
+            result = {
+                "destinations": recommendations,
+                "summary": "本地分析推荐结果"
+            }
+            return json.dumps(result, ensure_ascii=False)
+
+        # 简化的本地分析
+        destinations = self._extract_destinations(posts, wenlv_infos)
+
+        recommendations = []
+        for i, dest in enumerate(destinations[:10], 1):
+            recommendations.append({
+                "name": dest,
+                "rank": i,
+                "score": 5.0,
+                "reason": "本地分析结果",
+                "estimated_cost": "¥3000-5000",
+                "suggested_days": 5,
+                "best_time": "春秋季节",
+                "highlights": ["特色美食", "文化体验"]
+            })
+
+        result = {
+            "destinations": recommendations,
+            "summary": "本地分析推荐结果"
+        }
+        return json.dumps(result, ensure_ascii=False)
+
+    def _extract_destinations(
+        self,
+        posts: List[Dict],
+        wenlv_infos: List[Dict]
+    ) -> List[str]:
+        """从数据中提取目的地"""
+        common_destinations = [
+            "三亚", "云南", "大理", "丽江", "西双版纳",
+            "四川", "成都", "九寨沟", "川西",
+            "北京", "上海", "广州", "深圳",
+            "浙江", "杭州", "乌镇", "苏州", "南京",
+            "江苏", "陕西", "西安",
+            "广西", "桂林", "阳朔",
+            "海南", "西藏", "拉萨", "新疆", "喀纳斯",
+            "甘肃", "敦煌", "青海", "青海湖",
+            "黑龙江", "哈尔滨", "吉林", "长白山"
+        ]
+
+        destinations = {}
+
+        for post in posts:
+            text = f"{post.get('title', '')} {post.get('content', '')}"
+            for dest in common_destinations:
+                if dest in text:
+                    if dest not in destinations:
+                        destinations[dest] = {"posts": 0, "wenlv": 0}
+                    destinations[dest]["posts"] += 1
+
+        for info in wenlv_infos:
+            region = info.get("region", "")
+            if region and region != "全国":
+                if region not in destinations:
+                    destinations[region] = {"posts": 0, "wenlv": 0}
+                destinations[region]["wenlv"] += 1
+
+        # 按热度排序
+        sorted_dests = sorted(
+            destinations.items(),
+            key=lambda x: x[1]["posts"] * 2 + x[1]["wenlv"] * 3,
+            reverse=True
+        )
+
+        return [d[0] for d in sorted_dests]
+
+    async def analyze_destinations(
+        self,
+        posts: List[Dict],
+        wenlv_infos: List[Dict],
+        flights: List[Dict] = None,
+        hotels: List[Dict] = None
+    ) -> Dict[str, Any]:
+        """分析目的地数据
+
+        Args:
+            posts: 社交媒体帖子列表
+            wenlv_infos: 文旅信息列表
+            flights: 航班数据（可选）
+            hotels: 酒店数据（可选）
+
+        Returns:
+            分析结果字典
+        """
+        # 提取目的地
+        destinations = self._extract_destinations(posts, wenlv_infos)
+
+        # 为每个目的地计算评分
+        scored_destinations = []
+        for dest in destinations:
+            # 筛选相关数据
+            related_posts = [
+                p for p in posts
+                if dest in p.get("title", "") or dest in p.get("content", "")
+            ]
+            related_wenlv = [
+                w for w in wenlv_infos
+                if dest in w.get("title", "") or dest in w.get("content", "") or dest == w.get("region")
+            ]
+
+            # 计算评分
+            score_info = self.score_calculator.calculate_destination_score(
+                destination=dest,
+                posts=[SocialPost(**p) if isinstance(p, dict) else p for p in related_posts],
+                wenlv_infos=[WenlvInfo(**w) if isinstance(w, dict) else w for w in related_wenlv],
+            )
+
+            scored_destinations.append({
+                "name": dest,
+                "scores": score_info,
+                "post_count": len(related_posts),
+                "wenlv_count": len(related_wenlv),
+            })
+
+        # 按总分排序
+        scored_destinations.sort(
+            key=lambda x: x["scores"]["total_score"],
+            reverse=True
+        )
+
+        return {
+            "destinations": scored_destinations,
+            "total_analyzed": len(scored_destinations),
+            "top_destinations": [d["name"] for d in scored_destinations[:5]]
+        }
+
+    async def generate_recommendations(
+        self,
+        analysis_result: Dict[str, Any],
+        top_n: int = 10
+    ) -> str:
+        """生成推荐结果
+
+        Args:
+            analysis_result: 分析结果
+            top_n: 推荐数量
+
+        Returns:
+            推荐的 JSON 字符串
+        """
+        task = f"""基于以下分析结果，生成 TOP{top_n}旅行目的地推荐。
+
+对于每个目的地，请提供：
+1. 排名
+2. 目的地名称
+3. 综合得分（基于提供的分数）
+4. 推荐理由（100-200 字）
+5. 预估费用范围
+6. 建议游玩天数
+7. 最佳旅行时间
+8. 亮点特色（2-3 个）
+
+分析数据：
+{json.dumps(analysis_result, ensure_ascii=False, indent=2)}
+
+请输出 JSON 格式：
+{{
+    "destinations": [
+        {{
+            "name": "目的地",
+            "rank": 1,
+            "score": 8.5,
+            "reason": "推荐理由...",
+            "estimated_cost": "¥3000-5000",
+            "suggested_days": 5,
+            "best_time": "3-5 月",
+            "highlights": ["亮点 1", "亮点 2"]
+        }}
+    ],
+    "summary": "整体总结"
+}}
+"""
+
+        return await self.execute(task, {"analysis": analysis_result})

package/python/agents/base.py

@@ -0,0 +1,377 @@
+"""Agent 基类模块 - 支持多 LLM 提供商
+
+提供统一的 Agent 接口，支持 Anthropic/OpenAI/DeepSeek/Azure/Ollama 等厂商
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, List, Callable
+from config.settings import get_settings, LLM_PROVIDERS
+from tools.mcp_tools import Tool, ToolRegistry, ToolHandler, build_tool
+
+
+class BaseAgent(ABC):
+    """Agent 基类
+
+    所有子 Agent 都需要继承此类并实现具体方法
+
+    支持两种执行模式:
+    1. 纯文本对话 (默认)
+    2. Tool Use 模式 (需要配置 tools)
+
+    支持的 LLM 提供商:
+    - Anthropic (claude-sonnet-4-6, claude-opus-4-6, ...)
+    - OpenAI (gpt-4o, gpt-4-turbo, ...)
+    - DeepSeek (deepseek-chat, deepseek-coder)
+    - Azure OpenAI
+    - Ollama (本地部署)
+    """
+
+    name: str = "base_agent"
+    role: str = "助手"
+    goal: str = "帮助用户完成任务"
+
+    # 子类可定义可用的工具列表（MCP 格式）
+    # 使用 build_tool() 构建符合 MCP 标准的工具定义
+    available_tools: Dict[str, Tool] = {}
+    tool_handlers: Dict[str, ToolHandler] = {}
+
+    def __init__(
+        self,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        use_tools: bool = False,
+    ):
+        """初始化 Agent
+
+        Args:
+            provider: LLM 提供商 (anthropic/openai/deepseek/azure/ollama)
+            model: 使用的模型名称，留空则使用配置中的默认模型
+            use_tools: 是否启用 Tool Use 模式
+        """
+        self.settings = get_settings()
+
+        # 确定使用的提供商和模型
+        self.provider = provider or self.settings.llm_provider or "anthropic"
+        self.model = model or self.settings.llm_model or self.settings.get_active_model()
+        self.use_tools = use_tools
+
+        # 工具注册表
+        self.tool_registry = ToolRegistry()
+
+        # 初始化客户端
+        self.client = self._init_client()
+
+        # 注册工具
+        self._register_tools()
+
+    def _init_client(self):
+        """初始化 LLM 客户端
+
+        根据配置的提供商初始化对应的客户端
+        """
+        if not self.settings.is_provider_configured(self.provider):
+            print(f"[{self.name}] 警告：{self.provider} 未配置，将使用降级模式")
+            return None
+
+        try:
+            if self.provider == "anthropic":
+                from anthropic import Anthropic
+                return Anthropic(api_key=self.settings.anthropic_api_key)
+
+            elif self.provider == "openai":
+                from openai import OpenAI
+                return OpenAI(api_key=self.settings.openai_api_key)
+
+            elif self.provider == "deepseek":
+                from openai import OpenAI  # DeepSeek 使用 OpenAI 兼容接口
+                return OpenAI(
+                    api_key=self.settings.deepseek_api_key,
+                    base_url="https://api.deepseek.com"
+                )
+
+            elif self.provider == "azure":
+                from openai import AzureOpenAI
+                return AzureOpenAI(
+                    api_key=self.settings.azure_openai_api_key,
+                    azure_endpoint=self.settings.azure_openai_endpoint,
+                    api_version=self.settings.azure_openai_api_version,
+                )
+
+            elif self.provider == "ollama":
+                from openai import OpenAI  # Ollama 使用 OpenAI 兼容接口
+                return OpenAI(
+                    base_url=self.settings.ollama_base_url,
+                    api_key="ollama",  # Ollama 不需要真实 Key
+                )
+
+            elif self.provider == "qwen":
+                from openai import OpenAI  # Qwen 使用 OpenAI 兼容接口
+                return OpenAI(
+                    api_key=self.settings.dashscope_api_key,
+                    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
+                )
+
+            else:
+                print(f"[{self.name}] 未知提供商：{self.provider}")
+                return None
+
+        except ImportError as e:
+            print(f"[{self.name}] 导入客户端库失败：{e}")
+            print(f"请安装对应的依赖：pip install anthropic openai")
+            return None
+
+        except Exception as e:
+            print(f"[{self.name}] 初始化客户端失败：{e}")
+            return None
+
+    def _register_tools(self):
+        """注册工具
+
+        子类可以在 available_tools 中定义工具（MCP 格式），在 tool_handlers 中定义处理函数
+        工具会被注册到 tool_registry 中，支持动态添加和调用
+        """
+        # 注册类变量中定义的工具
+        for tool_name, tool_def in self.available_tools.items():
+            handler = self.tool_handlers.get(tool_name)
+            if handler:
+                self.tool_registry.register(tool_def, handler)
+
+    def _get_tool_definitions(self) -> List[Tool]:
+        """获取工具定义列表（MCP 标准格式）
+
+        返回 Claude API / MCP 兼容的工具定义
+        """
+        return self.tool_registry.get_definitions()
+
+    def _build_prompt(self, task: str, context: Dict[str, Any]) -> str:
+        """构建 Prompt
+
+        Args:
+            task: 任务描述
+            context: 上下文信息
+
+        Returns:
+            完整的 prompt 字符串
+        """
+        context_str = ""
+        if context:
+            import json
+            clean_context = {}
+            for k, v in context.items():
+                if hasattr(v, 'dict') or hasattr(v, 'model_dump'):
+                    clean_context[k] = v.model_dump() if hasattr(v, 'model_dump') else v.dict()
+                elif isinstance(v, list) and len(v) > 0 and hasattr(v[0], 'dict'):
+                    clean_context[k] = [
+                        item.model_dump() if hasattr(item, 'model_dump') else item.dict()
+                        for item in v[:10]
+                    ]
+                else:
+                    clean_context[k] = v
+
+            context_str = json.dumps(clean_context, ensure_ascii=False, indent=2, default=str)
+
+        return f"""你是一个{self.role}。
+你的目标：{self.goal}
+
+当前任务：
+{task}
+
+上下文信息：
+{context_str if context_str else "无"}
+
+请完成你的任务，直接输出结果："""
+
+    async def _execute_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str:
+        """执行工具调用（通过 tool_registry）
+
+        Args:
+            tool_name: 工具名称
+            tool_input: 工具参数
+
+        Returns:
+            工具执行结果
+        """
+        try:
+            result = await self.tool_registry.call(tool_name, **tool_input)
+            return str(result)
+        except ValueError as e:
+            return f"错误：未知工具 {tool_name}"
+        except Exception as e:
+            return f"工具执行失败：{e}"
+
+    async def execute(
+        self,
+        task: str,
+        context: Optional[Dict[str, Any]] = None,
+        system_prompt: Optional[str] = None,
+        max_tokens: int = 2048,
+        use_tool_mode: Optional[bool] = None,
+    ) -> str:
+        """执行任务
+
+        Args:
+            task: 任务描述
+            context: 上下文信息
+            system_prompt: 可选的系统 prompt
+            max_tokens: 最大输出 token 数
+            use_tool_mode: 是否使用 Tool Use 模式，None 则使用实例配置
+
+        Returns:
+            Agent 执行结果
+        """
+        context = context or {}
+        use_tool = use_tool_mode if use_tool_mode is not None else self.use_tools
+
+        # 如果没有客户端，使用本地执行
+        if not self.client:
+            return await self.execute_local(task, context)
+
+        # Tool Use 模式
+        if use_tool and self.available_tools:
+            return await self._execute_with_tools(
+                task, context, system_prompt, max_tokens
+            )
+
+        # 普通文本模式
+        prompt = self._build_prompt(task, context)
+
+        try:
+            if self.provider == "anthropic":
+                return await self._call_anthropic(prompt, system_prompt, max_tokens)
+            else:
+                return await self._call_openai_compatible(prompt, system_prompt, max_tokens)
+
+        except Exception as e:
+            print(f"[{self.name}] API 调用失败：{e}，降级为本地执行")
+            return await self.execute_local(task, context)
+
+    async def _call_anthropic(
+        self,
+        prompt: str,
+        system_prompt: Optional[str],
+        max_tokens: int
+    ) -> str:
+        """调用 Anthropic API"""
+        messages = [{"role": "user", "content": prompt}]
+        if system_prompt:
+            messages.insert(0, {"role": "system", "content": system_prompt})
+
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=max_tokens,
+            messages=messages,
+        )
+        return response.content[0].text
+
+    async def _call_openai_compatible(
+        self,
+        prompt: str,
+        system_prompt: Optional[str],
+        max_tokens: int
+    ) -> str:
+        """调用 OpenAI 兼容 API (OpenAI/DeepSeek/Azure/Ollama)"""
+        messages = [{"role": "user", "content": prompt}]
+        if system_prompt:
+            messages.insert(0, {"role": "system", "content": system_prompt})
+
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            max_tokens=max_tokens,
+        )
+        return response.choices[0].message.content
+
+    async def _execute_with_tools(
+        self,
+        task: str,
+        context: Dict[str, Any],
+        system_prompt: Optional[str],
+        max_tokens: int = 2048
+    ) -> str:
+        """使用 Tool Use 模式执行任务"""
+        # 注意：Tool Use 目前仅支持 Anthropic
+        if self.provider != "anthropic":
+            print(f"[{self.name}] Tool Use 仅支持 Anthropic，降级为普通模式")
+            return await self.execute(task, context, system_prompt, max_tokens, use_tool_mode=False)
+
+        prompt = self._build_prompt(task, context)
+        messages = [{"role": "user", "content": prompt}]
+
+        try:
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                system=system_prompt or f"你是一个{self.role}。{self.goal}",
+                messages=messages,
+                tools=self._get_tool_definitions() if self.available_tools else None,
+            )
+
+            final_result = []
+            tool_results = []
+
+            for content in response.content:
+                if content.type == "text":
+                    final_result.append(content.text)
+                elif content.type == "tool_use":
+                    tool_name = content.name
+                    tool_input = content.input
+                    tool_id = content.id
+
+                    tool_result = await self._execute_tool(tool_name, tool_input)
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": tool_id,
+                        "content": tool_result,
+                    })
+
+            if tool_results:
+                messages.append(response)
+                messages.append({
+                    "role": "user",
+                    "content": tool_results,
+                })
+
+                response2 = self.client.messages.create(
+                    model=self.model,
+                    max_tokens=max_tokens,
+                    messages=messages,
+                    tools=self._get_tool_definitions() if self.available_tools else None,
+                )
+
+                for content in response2.content:
+                    if content.type == "text":
+                        final_result.append(content.text)
+
+            return "\n".join(final_result)
+
+        except Exception as e:
+            print(f"[{self.name}] Tool Use 执行失败：{e}，降级为普通模式")
+            return await self.execute(task, context, system_prompt, max_tokens, use_tool_mode=False)
+
+    @abstractmethod
+    def execute_local(self, task: str, context: Dict[str, Any]) -> str:
+        """本地执行逻辑（API 不可用时降级）
+
+        Args:
+            task: 任务描述
+            context: 上下文信息
+
+        Returns:
+            执行结果
+        """
+        pass
+
+    def switch_provider(self, provider: str, model: Optional[str] = None):
+        """切换 LLM 提供商
+
+        Args:
+            provider: 新的提供商
+            model: 可选的模型名称
+        """
+        self.provider = provider
+        if model:
+            self.model = model
+        self.client = self._init_client()
+        print(f"[{self.name}] 已切换到 {provider}/{self.model}")
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(provider={self.provider}, model={self.model})"