travel-agent-cli 0.2.0 → 0.2.2

package/python/agents/collector_agent.py

@@ -0,0 +1,304 @@
+"""采集 Agent - 负责数据采集任务
+
+支持 Tool Use 模式，Claude 可以自主决定调用哪个采集工具
+"""
+from typing import Dict, Any, List
+from agents.base import BaseAgent
+from tools.mcp_tools import build_tool, string_property, integer_property
+from collectors.xiaohongshu import XiaohongshuCollector
+from collectors.weibo import WeiboCollector
+from collectors.wenlv import WenlvCollector
+from collectors.ota.fliggy import FliggyCollector
+from collectors.ota.ctrip import CtripCollector
+
+
+class CollectionAgent(BaseAgent):
+    """采集 Agent
+
+    职责：
+    - 采集社交媒体热点（小红书、微博）
+    - 采集文旅局官方信息
+    - 采集 OTA 机酒价格
+
+    可用工具（MCP 标准格式）：
+    - search_social_media: 搜索社交媒体
+    - collect_wenlv_info: 采集文旅信息
+    - search_flights: 搜索机票
+    - search_hotels: 搜索酒店
+    """
+
+    name = "collection_agent"
+    role = "旅行数据采集专家"
+    goal = "从多个来源采集高质量的旅行相关数据，包括社交媒体热点、官方政策和机酒价格"
+
+    # 定义可用的工具（MCP 标准格式）
+    available_tools = {
+        "search_social_media": build_tool(
+            name="search_social_media",
+            description="搜索社交媒体平台上的旅行相关内容",
+            properties={
+                "keyword": string_property(
+                    "搜索关键词，例如 '三亚旅行'、'海岛游'"
+                ),
+                "platform": string_property(
+                    "目标平台：xiaohongshu(小红书), weibo(微博), all(全部)",
+                    enum=["xiaohongshu", "weibo", "all"],
+                    default="all"
+                ),
+                "limit": integer_property(
+                    "返回结果数量限制",
+                    minimum=1,
+                    maximum=100,
+                    default=20
+                )
+            },
+            required=["keyword"]
+        ),
+        "collect_wenlv_info": build_tool(
+            name="collect_wenlv_info",
+            description="采集各地文旅局官网的政策、活动和推荐路线信息",
+            properties={
+                "region": string_property(
+                    "可选的地区名称，例如 '云南'、'浙江'，不传则采集全部"
+                )
+            },
+            required=[]
+        ),
+        "search_flights": build_tool(
+            name="search_flights",
+            description="搜索航班价格信息",
+            properties={
+                "departure_city": string_property(
+                    "出发城市，例如 '北京'、'上海'"
+                ),
+                "arrival_city": string_property(
+                    "到达城市，例如 '三亚'、'成都'"
+                ),
+                "date": string_property(
+                    "出发日期，格式 YYYY-MM-DD，不传则搜索近期"
+                )
+            },
+            required=["departure_city", "arrival_city"]
+        ),
+        "search_hotels": build_tool(
+            name="search_hotels",
+            description="搜索酒店价格信息",
+            properties={
+                "destination": string_property(
+                    "目的地城市，例如 '三亚'、'成都'"
+                ),
+                "price_min": integer_property(
+                    "最低价格（元/晚）"
+                ),
+                "price_max": integer_property(
+                    "最高价格（元/晚）"
+                )
+            },
+            required=["destination"]
+        )
+    }
+
+    def __init__(self, provider: str = None, model: str = None, use_tools: bool = True):
+        # 先设置工具处理函数，再调用父类初始化
+        # 这样 _register_tools() 才能正确注册
+        self.tool_handlers = {
+            "search_social_media": self._handle_search_social_media,
+            "collect_wenlv_info": self._handle_collect_wenlv,
+            "search_flights": self._handle_search_flights,
+            "search_hotels": self._handle_search_hotels,
+        }
+
+        super().__init__(provider, model, use_tools)
+
+    async def execute_local(self, task: str, context: Dict[str, Any]) -> str:
+        """本地执行采集"""
+        sources = context.get("sources", ["xiaohongshu", "weibo", "wenlv"])
+        keyword = context.get("keyword", "旅行")
+
+        results = []
+        for source in sources:
+            if source in self.collectors:
+                results.append(f"✓ {source}: 采集完成（模拟数据）")
+
+        return f"采集结果:\n" + "\n".join(results)
+
+    # ========== 工具处理函数 ==========
+
+    async def _handle_search_social_media(
+        self,
+        keyword: str,
+        platform: str = "all",
+        limit: int = 20
+    ) -> str:
+        """处理社交媒体搜索工具"""
+        result = {"posts": [], "stats": {}}
+
+        platforms = ["xiaohongshu", "weibo"] if platform == "all" else [platform]
+
+        if "xiaohongshu" in platforms:
+            collector = XiaohongshuCollector()
+            posts = await collector.search(keyword=keyword, page_size=limit)
+            result["posts"].extend([p.model_dump() for p in posts])
+            result["stats"]["xiaohongshu_count"] = len(posts)
+
+        if "weibo" in platforms:
+            collector = WeiboCollector()
+            posts = await collector.search(keyword=keyword, count=limit)
+            result["posts"].extend([p.model_dump() for p in posts])
+            result["stats"]["weibo_count"] = len(posts)
+
+        import json
+        return json.dumps(result, ensure_ascii=False, default=str)
+
+    async def _handle_collect_wenlv(self, region: str = None) -> str:
+        """处理文旅信息采集工具"""
+        collector = WenlvCollector()
+        infos = await collector.collect()
+
+        # 按地区过滤
+        if region:
+            infos = [i for i in infos if region in i.region]
+
+        result = {
+            "infos": [i.model_dump() for i in infos],
+            "stats": {"wenlv_count": len(infos)}
+        }
+
+        import json
+        return json.dumps(result, ensure_ascii=False, default=str)
+
+    async def _handle_search_flights(
+        self,
+        departure_city: str,
+        arrival_city: str,
+        date: str = None
+    ) -> str:
+        """处理航班搜索工具"""
+        collector = FliggyCollector()
+        flights = await collector.search_flights(departure_city, arrival_city, date)
+
+        result = {
+            "flights": [f.model_dump() for f in flights],
+            "stats": {"count": len(flights)}
+        }
+
+        import json
+        return json.dumps(result, ensure_ascii=False, default=str)
+
+    async def _handle_search_hotels(
+        self,
+        destination: str,
+        price_min: int = None,
+        price_max: int = None
+    ) -> str:
+        """处理酒店搜索工具"""
+        collector = FliggyCollector()
+        hotels = await collector.search_hotels(
+            destination,
+            price_min=price_min,
+            price_max=price_max
+        )
+
+        result = {
+            "hotels": [h.model_dump() for h in hotels],
+            "stats": {"count": len(hotels)}
+        }
+
+        import json
+        return json.dumps(result, ensure_ascii=False, default=str)
+
+    # ========== 高级方法（供 Manager 调用） ==========
+
+    async def collect_social_media(
+        self,
+        keyword: str = "旅行",
+        sources: List[str] = None
+    ) -> Dict[str, Any]:
+        """采集社交媒体数据"""
+        if sources is None:
+            sources = ["xiaohongshu", "weibo"]
+
+        result = {"posts": [], "stats": {}}
+
+        if "xiaohongshu" in sources:
+            collector = XiaohongshuCollector()
+            posts = await collector.search(keyword=keyword)
+            result["posts"].extend([p.model_dump() for p in posts])
+            result["stats"]["xiaohongshu_count"] = len(posts)
+
+        if "weibo" in sources:
+            collector = WeiboCollector()
+            posts = await collector.search(keyword=keyword)
+            result["posts"].extend([p.model_dump() for p in posts])
+            result["stats"]["weibo_count"] = len(posts)
+
+        return result
+
+    async def collect_wenlv(self) -> Dict[str, Any]:
+        """采集文旅局信息"""
+        collector = WenlvCollector()
+        infos = await collector.collect()
+
+        return {
+            "infos": [i.model_dump() for i in infos],
+            "stats": {"wenlv_count": len(infos)}
+        }
+
+    async def collect_ota(
+        self,
+        destinations: List[str],
+        departure_city: str = "北京"
+    ) -> Dict[str, Any]:
+        """采集 OTA 机酒数据"""
+        result = {"flights": [], "hotels": [], "stats": {}}
+
+        flight_collector = FliggyCollector()
+        hotel_collector = FliggyCollector()
+
+        for dest in destinations[:5]:
+            flights = await flight_collector.search_flights(departure_city, dest)
+            hotels = await hotel_collector.search_hotels(dest)
+            result["flights"].extend([f.model_dump() for f in flights])
+            result["hotels"].extend([h.model_dump() for h in hotels])
+
+        result["stats"]["flight_count"] = len(result["flights"])
+        result["stats"]["hotel_count"] = len(result["hotels"])
+
+        return result
+
+    async def collect_all(
+        self,
+        keyword: str = "旅行",
+        include_ota: bool = True
+    ) -> Dict[str, Any]:
+        """执行完整采集流程"""
+        result = {
+            "social_media": await self.collect_social_media(keyword),
+            "wenlv": await self.collect_wenlv(),
+        }
+
+        if include_ota:
+            destinations = self._extract_destinations_from_posts(
+                result["social_media"]["posts"]
+            )
+            result["ota"] = await self.collect_ota(destinations)
+
+        return result
+
+    def _extract_destinations_from_posts(self, posts: List[Dict]) -> List[str]:
+        """从帖子中提取目的地"""
+        common_destinations = [
+            "三亚", "云南", "大理", "丽江", "四川", "成都",
+            "北京", "上海", "浙江", "杭州", "江苏", "苏州",
+            "陕西", "西安", "广西", "桂林", "海南", "西藏",
+            "新疆", "甘肃", "青海", "黑龙江", "哈尔滨"
+        ]
+
+        destinations = set()
+        for post in posts:
+            text = f"{post.get('title', '')} {post.get('content', '')}"
+            for dest in common_destinations:
+                if dest in text:
+                    destinations.add(dest)
+
+        return list(destinations)[:10]

package/python/agents/manager_agent.py

@@ -0,0 +1,251 @@
+"""Manager Agent - 多 Agent 系统协调者
+
+负责任务分配、Agent 间协调、结果汇总
+"""
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+import json
+
+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
+
+
+class ManagerAgent(BaseAgent):
+    """Manager Agent - 多 Agent 系统协调者
+
+    职责：
+    - 接收用户请求
+    - 分解任务并分配给子 Agent
+    - 协调 Agent 间的数据流
+    - 汇总最终结果
+
+    工作流程：
+    1. CollectionAgent → 采集数据
+    2. AnalysisAgent → 分析排序
+    3. PlanningAgent → 路线规划
+    4. ReportAgent → 报告生成
+    """
+
+    name = "manager_agent"
+    role = "旅行推荐系统总协调员"
+    goal = "协调多个专业 Agent，高效完成旅行目的地推荐任务"
+
+    def __init__(
+        self,
+        provider: Optional[str] = None,
+        model: Optional[str] = None,
+        use_tools: bool = False,
+    ):
+        super().__init__(provider, model, use_tools)
+
+        # 初始化子 Agent 团队（使用相同的配置）
+        self.team = {
+            "collector": CollectionAgent(provider, model, use_tools),
+            "analyst": AnalysisAgent(provider, model, use_tools),
+            "planner": PlanningAgent(provider, model, use_tools),
+            "reporter": ReportAgent(provider, model, use_tools),
+        }
+
+    async def execute_local(self, task: str, context: Dict[str, Any]) -> str:
+        """本地执行（降级模式）"""
+        return f"Manager Agent 本地执行：{task}"
+
+    async def run_workflow(
+        self,
+        keyword: str = "旅行",
+        include_ota: bool = True,
+        top_n: int = 10,
+        plan_top_n: int = 3,
+        verbose: bool = True
+    ) -> Dict[str, Any]:
+        """运行完整工作流
+
+        Args:
+            keyword: 采集关键词
+            include_ota: 是否包含 OTA 数据
+            top_n: 推荐目的地数量
+            plan_top_n: 规划路线的目的地数量
+            verbose: 是否输出详细日志
+
+        Returns:
+            完整结果字典
+        """
+        result = {
+            "status": "running",
+            "started_at": datetime.now().isoformat(),
+            "stages": {}
+        }
+
+        # ========== Stage 1: 数据采集 ==========
+        if verbose:
+            print(f"\n[{self.name}] 🚀 开始 Stage 1: 数据采集")
+
+        collector = self.team["collector"]
+        collection_result = await collector.collect_all(keyword, include_ota)
+
+        result["stages"]["collection"] = {
+            "social_media_count": len(collection_result.get("social_media", {}).get("posts", [])),
+            "wenlv_count": len(collection_result.get("wenlv", {}).get("infos", [])),
+            "flight_count": len(collection_result.get("ota", {}).get("flights", [])),
+            "hotel_count": len(collection_result.get("ota", {}).get("hotels", [])),
+        }
+
+        if verbose:
+            print(f"  ✓ 社交媒体：{result['stages']['collection']['social_media_count']} 条")
+            print(f"  ✓ 文旅信息：{result['stages']['collection']['wenlv_count']} 条")
+            if include_ota:
+                print(f"  ✓ 航班：{result['stages']['collection']['flight_count']} 条")
+                print(f"  ✓ 酒店：{result['stages']['collection']['hotel_count']} 条")
+
+        # ========== Stage 2: 数据分析 ==========
+        if verbose:
+            print(f"\n[{self.name}] 📊 开始 Stage 2: 数据分析")
+
+        analyst = self.team["analyst"]
+        all_posts = collection_result.get("social_media", {}).get("posts", [])
+        all_wenlv = collection_result.get("wenlv", {}).get("infos", [])
+        all_flights = collection_result.get("ota", {}).get("flights", [])
+        all_hotels = collection_result.get("ota", {}).get("hotels", [])
+
+        analysis_result = await analyst.analyze_destinations(
+            posts=all_posts,
+            wenlv_infos=all_wenlv,
+            flights=all_flights,
+            hotels=all_hotels
+        )
+
+        result["stages"]["analysis"] = {
+            "total_destinations": analysis_result.get("total_analyzed", 0),
+            "top_destinations": analysis_result.get("top_destinations", [])
+        }
+
+        if verbose:
+            print(f"  ✓ 分析目的地：{analysis_result.get('total_analyzed')} 个")
+            print(f"  ✓ TOP 目的地：{', '.join(analysis_result.get('top_destinations', [])[:5])}")
+
+        # 生成推荐
+        recommendations_json = await analyst.generate_recommendations(
+            analysis_result,
+            top_n=top_n
+        )
+
+        try:
+            recommendations = json.loads(recommendations_json)
+        except json.JSONDecodeError:
+            recommendations = {"destinations": [], "summary": ""}
+
+        result["stages"]["recommendations"] = recommendations
+
+        if verbose:
+            print(f"  ✓ 生成推荐：{len(recommendations.get('destinations', []))} 个")
+
+        # ========== Stage 3: 路线规划 ==========
+        if verbose:
+            print(f"\n[{self.name}] 🗺️ 开始 Stage 3: 路线规划")
+
+        planner = self.team["planner"]
+        destinations_for_planning = recommendations.get("destinations", [])[:plan_top_n]
+
+        routes = await planner.plan_top_destinations(
+            destinations_for_planning,
+            top_n=plan_top_n
+        )
+
+        result["stages"]["routes"] = routes
+
+        if verbose:
+            print(f"  ✓ 规划路线：{len(routes)} 条")
+
+        # ========== Stage 4: 报告生成 ==========
+        if verbose:
+            print(f"\n[{self.name}] 📝 开始 Stage 4: 报告生成")
+
+        reporter = self.team["reporter"]
+
+        # 生成摘要
+        summary = await reporter.write_summary(recommendations.get("destinations", []))
+
+        # 撰写完整报告
+        report_content = await reporter.write_report(
+            recommendations=recommendations.get("destinations", []),
+            routes=routes,
+            summary=summary
+        )
+
+        result["stages"]["report"] = {
+            "summary": summary,
+            "content": report_content,
+            "generated_at": datetime.now().isoformat()
+        }
+
+        if verbose:
+            print(f"  ✓ 报告生成完成")
+            print(f"  ✓ 报告长度：{len(report_content)} 字符")
+
+        # ========== 完成 ==========
+        result["status"] = "completed"
+        result["completed_at"] = datetime.now().isoformat()
+
+        if verbose:
+            print(f"\n[{self.name}] ✅ 工作流完成！")
+
+        return result
+
+    async def quick_recommend(
+        self,
+        keyword: str = "旅行",
+        top_n: int = 5
+    ) -> str:
+        """快速推荐（简化流程）
+
+        仅执行采集和分析，不生成详细路线和报告
+
+        Args:
+            keyword: 搜索关键词
+            top_n: 推荐数量
+
+        Returns:
+            简化推荐结果
+        """
+        print(f"[{self.name}] 执行快速推荐：{keyword}")
+
+        # 采集
+        collector = self.team["collector"]
+        collection = await collector.collect_all(keyword, include_ota=False)
+
+        # 分析
+        analyst = self.team["analyst"]
+        posts = collection.get("social_media", {}).get("posts", [])
+        wenlv = collection.get("wenlv", {}).get("infos", [])
+
+        analysis = await analyst.analyze_destinations(posts, wenlv)
+        recommendations = await analyst.generate_recommendations(analysis, top_n)
+
+        return recommendations
+
+    def get_team_status(self) -> Dict[str, Any]:
+        """获取团队状态
+
+        Returns:
+            各 Agent 状态信息
+        """
+        return {
+            "manager": {
+                "name": self.name,
+                "role": self.role,
+                "goal": self.goal,
+                "model": self.model
+            },
+            "team_members": {
+                name: {
+                    "name": agent.name,
+                    "role": agent.role,
+                    "goal": agent.goal
+                }
+                for name, agent in self.team.items()
+            },
+            "api_configured": self.client is not None
+        }