travel-agent-cli 0.1.0 → 0.2.1

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})"

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]