Spaces:

Eliot0110
/

Travel_Assistant

Running

App Files Files Community

Eliot0110 commited on Aug 6

Commit

05b4419

1 Parent(s): 502ec94

improve: knowledge base and re

Browse files

Files changed (3) hide show

modules/info_extractor.py +763 -301
modules/knowledge_base.py +274 -15
modules/response_generator.py +490 -127

modules/info_extractor.py CHANGED Viewed

@@ -1,356 +1,818 @@
 import json
 import re
 from utils.logger import log
-from .ai_model import AIModel
 class InfoExtractor:
-    def __init__(self, ai_model: AIModel):
-        self.ai_model = ai_model
         # 预定义的提取结构，用于验证和规范化
         self.extraction_schema = {
             "destination": {"type": dict, "fields": {"name": str, "country": str}},
             "duration": {"type": dict, "fields": {"days": int, "description": str}},
             "budget": {"type": dict, "fields": {"type": str, "amount": int, "currency": str, "description": str}}
         }
     def extract(self, user_message: str) -> dict:
-        """从用户消息中提取结构化信息，确保使用确定性解码。"""
         # 输入验证
         if not user_message or not isinstance(user_message, str):
             log.warning("⚠️ 收到无效的用户消息")
             return {}
-        # 构建prompt
-        prompt = self._build_prompt_template(user_message)
-        # --- 核心修复：强制使用确定性解码以杜绝幻觉 ---
-        log.info("🧠 使用LLM开始提取信息 (模式: 确定性)")
-        # 注意：ai_model.generate() 方法不支持 do_sample 和 temperature 参数
-        # 需要通过其他方式确保确定性输出
-        raw_response = self.ai_model.run_inference(
-            input_type="text",
-            formatted_input=None,
-            prompt=prompt,
-            temperature=0.0  # 使用最低温度确保确定性
-        )
-        try:
-            # 清理响应，提取纯JSON部分
-            cleaned_response = self._clean_json_response(raw_response)
-            extracted_json = json.loads(cleaned_response)
-            log.info(f"✅ LLM成功提取并解析JSON: {extracted_json}")
-            # 使用新的验证方法
-            validated_data = self._validate_and_normalize(extracted_json)
-            log.info(f"📊 LLM最终提取结果 (安全处理后): {validated_data}")
-            return validated_data
-        except (json.JSONDecodeError, TypeError) as e:
-            log.error(f"❌ 解析或验证LLM提取的JSON失败: {e}", exc_info=True)
-            log.debug(f"🔍 原始响应: {raw_response}")
-            # 尝试备用提取方法
-            return self._fallback_extraction(user_message)
-    def _clean_json_response(self, response: str) -> str:
-        """清理LLM响应，提取纯JSON部分"""
-        if not response:
-            return "{}"
-        # 移除可能的markdown代码块标记
-        response = re.sub(r'```json\s*', '', response)
-        response = re.sub(r'```\s*', '', response)
-        # 移除可能的前导文字
-        response = re.sub(r'^[^{]*', '', response)
-        # 查找第一个{和最后一个}
-        start_idx = response.find('{')
-        end_idx = response.rfind('}')
-        if start_idx != -1 and end_idx != -1 and end_idx > start_idx:
-            return response[start_idx:end_idx+1].strip()
-        # 如果找不到有效的JSON结构，返回空对象
-        return "{}"
-    def _fallback_extraction(self, user_message: str) -> dict:
-        """基于规则的备用信息提取"""
-        log.info("🔄 使用基于规则的备用提取方法")
         result = {}
-        message_lower = user_message.lower()
-        # 目的地提取 - 更全面的模式
-        city_patterns = [
-            r'去(\w+)', r'到(\w+)', r'想去(\w+)', r'前往(\w+)',
-            r'旅行(\w+)', r'游(\w+)', r'玩(\w+)', r'访问(\w+)',
-            r'目的地[\s是：:]*(\w+)', r'地方[\s是：:]*(\w+)'
         ]
-        for pattern in city_patterns:
-            match = re.search(pattern, user_message)
-            if match:
-                city_name = match.group(1)
-                if len(city_name) >= 2 and not city_name.isdigit():
-                    result["destination"] = {"name": city_name}
                     break
-        # 天数提取 - 更全面的模式
         day_patterns = [
-            r'(\d+)天', r'(\d+)日', r'玩(\d+)天', r'住(\d+)天',
-            r'(\d+)个天', r'呆(\d+)天', r'待(\d+)天', r'(\d+)天行程'
         ]
         for pattern in day_patterns:
-            match = re.search(pattern, user_message)
-            if match:
-                days = int(match.group(1))
-                if 1 <= days <= 365:  # 合理范围检查
-                    result["duration"] = {"days": days}
                     break
-        # 预算提取 - 更全面的模式
-        budget_patterns = [
-            r'(\d+)元', r'(\d+)块', r'预算(\d+)', r'(\d+)rmb',
-            r'(\d+)人民币', r'花(\d+)', r'费用(\d+)', r'(\d+)万'
         ]
-        for pattern in budget_patterns:
-            match = re.search(pattern, user_message)
-            if match:
-                amount = int(match.group(1))
-                # 处理"万"的情况
-                if '万' in pattern:
-                    amount *= 10000
-                result["budget"] = {
-                    "type": None,
-                    "amount": amount,
-                    "currency": "RMB"
-                }
                 break
-        # 预算类型识别
         budget_type_keywords = {
-            'economy': ['经济', '便宜', '省钱', '实惠', '节省'],
-            'comfortable': ['舒适', '中等', '适中', '一般'],
-            'luxury': ['豪华', '奢华', '高端', '贵一点', '不差钱']
         }
         for budget_type, keywords in budget_type_keywords.items():
-            if any(keyword in message_lower for keyword in keywords):
-                if "budget" not in result:
-                    result["budget"] = {"type": budget_type, "amount": None, "currency": None}
-                else:
-                    result["budget"]["type"] = budget_type
                 break
-        log.info(f"🛠️ 备用提取结果: {result}")
         return result
-    def _validate_and_normalize(self, data: dict) -> dict:
-        """
-        根据预定义schema验证并规范化提取的数据。
-        这取代了之前返回列表的逻辑，只返回符合结构的键值对。
-        """
-        if not isinstance(data, dict):
-            return {}
-        validated_output = {}
-        # 验证destination
-        if "destination" in data:
-            dest_data = data["destination"]
-            if isinstance(dest_data, dict):
-                validated_dest = {}
-                if "name" in dest_data and isinstance(dest_data["name"], str):
-                    name = dest_data["name"].strip()
-                    if name:
-                        validated_dest["name"] = name
-                if "country" in dest_data and isinstance(dest_data["country"], str):
-                    country = dest_data["country"].strip()
-                    if country:
-                        validated_dest["country"] = country
-                if validated_dest:
-                    validated_output["destination"] = validated_dest
-        # 验证duration
-        if "duration" in data:
-            duration_data = data["duration"]
-            if isinstance(duration_data, dict):
-                validated_duration = {}
-                if "days" in duration_data:
-                    days = duration_data["days"]
-                    if isinstance(days, (int, float)) and 1 <= days <= 365:
-                        validated_duration["days"] = int(days)
-                if "description" in duration_data and isinstance(duration_data["description"], str):
-                    desc = duration_data["description"].strip()
-                    if desc:
-                        validated_duration["description"] = desc
-                if validated_duration:
-                    validated_output["duration"] = validated_duration
-        # 验证budget
-        if "budget" in data:
-            budget_data = data["budget"]
-            if isinstance(budget_data, dict):
-                validated_budget = {}
-                # 验证type
-                if "type" in budget_data:
-                    budget_type = budget_data["type"]
-                    if budget_type in ["economy", "comfortable", "luxury"]:
-                        validated_budget["type"] = budget_type
-                # 验证amount
-                if "amount" in budget_data:
-                    amount = budget_data["amount"]
-                    if isinstance(amount, (int, float)) and amount > 0:
-                        validated_budget["amount"] = int(amount)
-                # 验证currency
-                if "currency" in budget_data and isinstance(budget_data["currency"], str):
-                    currency = budget_data["currency"].strip()
-                    if currency:
-                        validated_budget["currency"] = currency
-                # 验证description
-                if "description" in budget_data and isinstance(budget_data["description"], str):
-                    desc = budget_data["description"].strip()
-                    if desc:
-                        validated_budget["description"] = desc
-                if validated_budget:
-                    validated_output["budget"] = validated_budget
-        if not validated_output:
-            log.warning(f"⚠️ 提取的数据 {data} 未通过验证，未发现任何有效字段。")
-        return validated_output
-    def _build_prompt_template(self, user_message: str) -> str:
-        """构建包含多个示例的提取prompt"""
-        # 输入长度控制
-        if len(user_message) > 300:
-            user_message = user_message[:300] + "..."
-        return f"""你的任务是且仅是作为文本解析器。
-严格分析用户输入，并以一个纯净、无注释的JSON对象格式返回。
-**核心规则:**
-1. **绝对禁止** 在JSON之外添加任何文本、注释、解释或Markdown标记。你的输出必须从 `{{` 开始，到 `}}` 结束。
-2. **必须严格遵守** 下方定义的嵌套JSON结构。不要创造新的键，也不要改变层级。
-3. 如果信息未提供，对应的键值必须为 `null`，而���是省略该键。
-4. 如果用户输入与旅行无关(如 "你好")，必须返回一个空的JSON对象: `{{}}`。
-**强制JSON输出结构:**
-{{
-  "destination": {{
-    "name": "string or null",
-    "country": "string or null"
-  }},
-  "duration": {{
-    "days": "integer or null",
-    "description": "string or null"
-  }},
-  "budget": {{
-    "type": "string ('economy', 'comfortable', 'luxury') or null",
-    "amount": "number or null",
-    "currency": "string or null",
-    "description": "string or null"
-  }}
-}}
-**示例1:**
-用户输入: "我想去柏林玩3天"
-你的输出:
-{{
-  "destination": {{
-    "name": "柏林",
-    "country": null
-  }},
-  "duration": {{
-    "days": 3,
-    "description": null
-  }},
-  "budget": {{
-    "type": null,
-    "amount": null,
-    "currency": null,
-    "description": null
-  }}
-}}
-**示例2:**
-用户输入: "计划去日本东京旅行一周，预算2万元"
-你的输出:
-{{
-  "destination": {{
-    "name": "东京",
-    "country": "日本"
-  }},
-  "duration": {{
-    "days": 7,
-    "description": "一周"
-  }},
-  "budget": {{
-    "type": null,
-    "amount": 20000,
-    "currency": "元",
-    "description": null
-  }}
-}}
-**示例3:**
-用户输入: "想要一个经济实惠的巴黎5天行程"
-你的输出:
-{{
-  "destination": {{
-    "name": "巴黎",
-    "country": null
-  }},
-  "duration": {{
-    "days": 5,
-    "description": null
-  }},
-  "budget": {{
-    "type": "economy",
-    "amount": null,
-    "currency": null,
-    "description": "经济实惠"
-  }}
-}}
-**示例4:**
-用户输入: "你好"
-你的输出:
-{{}}
-**示例5:**
-用户输入: "想去泰国普吉岛度蜜月，10天左右，豪华一点不差钱"
-你的输出:
-{{
-  "destination": {{
-    "name": "普吉岛",
-    "country": "泰国"
-  }},
-  "duration": {{
-    "days": 10,
-    "description": "10天左右"
-  }},
-  "budget": {{
-    "type": "luxury",
-    "amount": null,
-    "currency": null,
-    "description": "豪华一点不差钱"
-  }}
-}}
----
-**用户输入:**
-{user_message}
-**你的输出 (必须是纯JSON):**
-"""

 import json
 import re
 from utils.logger import log
 class InfoExtractor:
+    def __init__(self):
         # 预定义的提取结构，用于验证和规范化
         self.extraction_schema = {
             "destination": {"type": dict, "fields": {"name": str, "country": str}},
             "duration": {"type": dict, "fields": {"days": int, "description": str}},
             "budget": {"type": dict, "fields": {"type": str, "amount": int, "currency": str, "description": str}}
         }
+        # 欧洲城市和国家的完整映射关系（聚焦欧洲）
+        self.european_cities = {
+            # === 西欧 ===
+            # 法国
+            "巴黎": "法国", "里昂": "法国", "马赛": "法国", "尼斯": "法国", "戛纳": "法国",
+            "图卢兹": "法国", "南特": "法国", "斯特拉斯堡": "法国", "蒙彼利埃": "法国", "波尔多": "法国",
+            "里尔": "法国", "雷恩": "法国", "兰斯": "法国", "勒阿弗尔": "法国", "圣埃蒂安": "法国",
+            "土伦": "法国", "阿维尼翁": "法国", "凡尔赛": "法国", "枫丹白露": "法国", "第戎": "法国",
+            "昂热": "法国", "贝桑松": "法国", "佩皮尼昂": "法国", "卢尔德": "法国", "沙特尔": "法国",
+            # 德国
+            "柏林": "德国", "慕尼黑": "德国", "汉堡": "德国", "科隆": "德国", "法兰克福": "德国",
+            "斯图加特": "德国", "杜塞尔多夫": "德国", "多特蒙德": "德国", "埃森": "德国", "莱比锡": "德国",
+            "不来梅": "德国", "德累斯顿": "德国", "汉诺威": "德国", "纽伦堡": "德国", "杜伊斯堡": "德国",
+            "波鸿": "德国", "乌珀塔尔": "德国", "比勒费尔德": "德国", "波恩": "德国", "明斯特": "德国",
+            "卡尔斯鲁厄": "德国", "曼海姆": "德国", "奥格斯堡": "德国", "威斯巴登": "德国", "盖尔森基兴": "德国",
+            "门兴格拉德巴赫": "德国", "布伦瑞克": "德国", "基尔": "德国", "亚琛": "德国", "哈雷": "德国",
+            "马格德堡": "德国", "弗莱堡": "德国", "克里菲尔德": "德国", "吕贝克": "德国", "奥伯豪森": "德国",
+            "埃尔福特": "德国", "罗斯托克": "德国", "凯泽斯劳滕": "德国", "卡塞尔": "德国", "哈根": "德国",
+            "波茨坦": "德国", "萨尔布吕肯": "德国", "路德维希港": "德国", "奥尔登堡": "德国", "莱沃库森": "德国",
+            "奥斯纳布吕克": "德国", "索林根": "德国", "海德堡": "德国", "达姆施塔特": "德国", "哈姆": "德国",
+            "维尔茨堡": "德国", "雷克林豪森": "德国", "沃尔夫斯堡": "德国", "格廷根": "德国", "科特布斯": "德国",
+            "希尔德斯海姆": "德国", "埃朗根": "德国", "特里尔": "德国", "耶拿": "德国", "康斯坦茨": "德国",
+            "新天鹅堡": "德国", "罗滕堡": "德国", "科布伦茨": "德国", "班贝格": "德国", "拜罗伊特": "德国",
+            # 英国
+            "伦敦": "英国", "伯明翰": "英国", "曼彻斯特": "英国", "格拉斯哥": "英国", "利物浦": "英国",
+            "利兹": "英国", "谢菲尔德": "英国", "爱丁堡": "英国", "布里斯托": "英国", "莱斯特": "英国",
+            "考文垂": "英国", "布拉德福德": "英国", "贝尔法斯特": "英国", "卡迪夫": "英国", "诺丁汉": "英国",
+            "金斯顿": "英国", "纽卡斯尔": "英国", "普利茅斯": "英国", "斯托克": "英国", "南安普顿": "英国",
+            "雷丁": "英国", "德比": "英国", "约克": "英国", "牛津": "英国", "剑桥": "英国",
+            "巴斯": "英国", "温莎": "英国", "坎特伯雷": "英国", "斯特拉特福": "英国", "湖区": "英国",
+            "斯凯岛": "英国", "爱丁堡": "英国", "格拉斯哥": "英国", "史德灵": "英国", "珀斯": "英国",
+            "因弗内斯": "英国", "阿伯丁": "英国", "邓迪": "英国", "法夫": "英国", "奥班": "英国",
+            # 荷兰
+            "阿姆斯特丹": "荷兰", "鹿特丹": "荷兰", "海牙": "荷兰", "乌得勒支": "荷兰", "埃因霍温": "荷兰",
+            "蒂尔堡": "荷兰", "格罗宁根": "荷兰", "阿尔梅勒": "荷兰", "布雷达": "荷兰", "奈梅亨": "荷兰",
+            "阿珀尔多伦": "荷兰", "哈勒姆": "荷兰", "阿纳姆": "荷兰", "恩斯赫德": "荷兰", "阿默斯福特": "荷兰",
+            "赞丹": "荷兰", "海牙": "荷兰", "阿尔克马尔": "荷兰", "马斯特里赫特": "荷兰", "莱顿": "荷兰",
+            "代尔夫特": "荷兰", "多德雷赫特": "荷兰", "豪达": "荷兰", "羊角村": "荷兰", "马尔肯": "荷兰",
+            # 比利时
+            "布鲁塞尔": "比利时", "安特卫普": "比利时", "根特": "比利时", "沙勒罗瓦": "比利时", "列日": "比利时",
+            "布吕赫": "比利时", "那慕尔": "比利时", "蒙斯": "比利时", "阿尔斯特": "比利时", "科特赖克": "比利时",
+            "哈瑟尔特": "比利时", "圣尼古拉": "比利时", "奥斯坦德": "比利时", "梅赫伦": "比利时", "鲁汶": "比利时",
+            # 卢森堡
+            "卢森堡市": "卢森堡", "埃施": "卢森堡", "迪费当日": "卢森堡", "杜德朗日": "卢森堡",
+            # === 南欧 ===
+            # 意大利
+            "罗马": "意大利", "米兰": "意大利", "威尼斯": "意大利", "佛罗伦萨": "意大利", "那不勒斯": "意大利",
+            "都灵": "意大利", "帕勒莫": "意大利", "热那亚": "意大利", "博洛尼亚": "意大利", "巴里": "意大利",
+            "卡塔尼亚": "意大利", "佛罗伦萨": "意大利", "韦罗纳": "意大利", "威尼斯": "意大利", "墨西拿": "意大利",
+            "帕多瓦": "意大利", "的里雅斯特": "意大利", "塔兰托": "意大利", "布雷西亚": "意大利", "摩德纳": "意大利",
+            "雷焦卡拉布里亚": "意大利", "普拉托": "意大利", "卡利亚里": "意大利", "帕尔马": "意大利", "佩鲁贾": "意大利",
+            "利沃诺": "意大利", "雷焦艾米利亚": "意大利", "佛嘉": "意大利", "萨莱诺": "意大利", "拉温纳": "意大利",
+            "里米尼": "意大利", "拉斯佩齐亚": "意大利", "萨萨里": "意大利", "蒙扎": "意大利", "贝加莫": "意大利",
+            "比萨": "意大利", "维琴察": "意大利", "三月十五日": "意大利", "博尔扎诺": "意大利", "安德里亚": "意大利",
+            "阿雷佐": "意大利", "蒂沃利": "意大利", "阿西西": "意大利", "锡耶纳": "意大利", "五渔村": "意大利",
+            "马泰拉": "意大利", "庞贝": "意大利", "卡普里岛": "意大利", "阿马尔菲": "意大利", "科莫": "意大利",
+            # 西班牙
+            "马德里": "西班牙", "巴塞罗那": "西班牙", "瓦伦西亚": "西班牙", "塞维利亚": "西班牙", "萨拉戈萨": "西班牙",
+            "马拉加": "西班牙", "穆尔西亚": "西班牙", "帕尔马": "西班牙", "拉斯帕尔马斯": "西班牙", "毕尔巴鄂": "西班牙",
+            "阿利坎特": "西班牙", "科尔多瓦": "西班牙", "巴利亚多利德": "西班牙", "维戈": "西班牙", "希洪": "西班牙",
+            "莱昂": "西班牙", "拉科鲁尼亚": "西班牙", "埃尔切": "西班牙", "奥维耶多": "西班牙", "圣塞巴斯蒂安": "西班牙",
+            "桑坦德": "西班牙", "卡斯特利翁": "西班牙", "洛格罗尼奥": "西班牙", "巴达霍斯": "西班牙", "萨拉曼卡": "西班牙",
+            "韦尔瓦": "西班牙", "阿尔梅里亚": "西班牙", "卡迪斯": "西班牙", "格拉纳达": "西班牙", "托莱多": "西班牙",
+            "昆卡": "西班牙", "卡塞雷斯": "西班牙", "塞哥维亚": "西班牙", "阿维拉": "西班牙", "布尔戈斯": "西班牙",
+            "马略卡岛": "西班牙", "伊比萨": "西班牙", "特内里费": "西班牙", "大加那利": "西班牙", "兰萨罗特": "西班牙",
+            # 葡萄牙
+            "里斯本": "葡萄牙", "波尔图": "葡萄牙", "阿马多拉": "葡萄牙", "布拉加": "葡萄牙", "塞图巴尔": "葡萄牙",
+            "科英布拉": "葡萄牙", "丰沙尔": "葡萄牙", "阿威罗": "葡萄牙", "埃武拉": "葡萄牙", "法鲁": "葡萄牙",
+            "阿尔布费拉": "葡萄牙", "辛特拉": "葡萄牙", "卡斯凯什": "葡萄牙", "奥比杜什": "葡萄牙", "波尔塔莱格雷": "葡萄牙",
+            "吉马良斯": "葡萄牙", "维亚纳堡": "葡萄牙", "维塞乌": "葡萄牙", "拉戈什": "葡萄牙", "萨格里什": "葡萄牙",
+            # 希腊
+            "雅典": "希腊", "塞萨洛尼基": "希腊", "帕特雷": "希腊", "伊拉克利翁": "希腊", "拉里萨": "希腊",
+            "沃洛斯": "希腊", "约阿尼纳": "希腊", "卡瓦拉": "希腊", "哈尼亚": "希腊", "塞雷斯": "希腊",
+            "圣托里尼": "希腊", "米科诺斯": "希腊", "罗德岛": "希腊", "科孚": "希腊", "克里特": "希腊",
+            "帕罗斯": "希腊", "纳克索斯": "希腊", "扎金索斯": "希腊", "凯法利尼亚": "希腊", "斯基亚索斯": "希腊",
+            "德尔菲": "希腊", "奥林匹亚": "希腊", "迈锡尼": "希腊", "埃皮达鲁斯": "希腊", "梅泰奥拉": "希腊",
+            # === 中欧 ===
+            # 奥地利
+            "维也纳": "奥地利", "格拉茨": "奥地利", "林茨": "奥地利", "萨尔茨堡": "奥地利", "因斯布鲁克": "奥地利",
+            "克拉根福": "奥地利", "菲拉赫": "奥地利", "韦尔斯": "奥地利", "圣珀尔滕": "奥地利", "多恩比恩": "奥地��",
+            "维也纳新城": "奥地利", "施泰尔": "奥地利", "费尔德基兴": "奥地利", "布鲁克": "奥地利", "莱奥本": "奥地利",
+            "哈尔施塔特": "奥地利", "巴德伊舍尔": "奥地利", "梅尔克": "奥地利", "瓦绍": "奥地利", "库夫斯坦": "奥地利",
+            # 捷克
+            "布拉格": "捷克", "布尔诺": "捷克", "俄斯特拉发": "捷克", "比尔森": "捷克", "奥洛穆茨": "捷克",
+            "利贝雷茨": "捷克", "赫拉德茨克拉洛韦": "捷克", "乌斯季": "捷克", "帕尔杜比采": "捷克", "兹林": "捷克",
+            "哈维若夫": "捷克", "克拉德诺": "捷克", "切斯凯布杰约维采": "捷克", "莫斯特": "捷克", "卡尔维纳": "捷克",
+            "库特纳霍拉": "捷克", "泰尔奇": "捷克", "克鲁姆洛夫": "捷克", "卡尔什特因": "捷克", "布拉格城堡": "捷克",
+            # 匈牙利
+            "布达佩斯": "匈牙利", "德布勒森": "匈牙利", "塞格德": "匈牙利", "米什科尔茨": "匈牙利", "佩奇": "匈牙利",
+            "焦尔": "匈牙利", "尼赖吉哈佐": "匈牙利", "凯奇凯梅特": "匈牙利", "塞克什白堡": "匈牙利", "松博特海伊": "匈牙利",
+            "松博特海伊": "匈牙利", "维斯普雷姆": "匈牙利", "埃格尔": "匈牙利", "贝凯什乔包": "匈牙利", "大沃拉丁": "匈牙利",
+            "埃斯泰尔戈姆": "匈牙利", "维谢格拉德": "匈牙利", "霍洛克": "匈牙利", "蒂豪尼": "匈牙利", "巴拉顿湖": "匈牙利",
+            # 波兰
+            "华沙": "波兰", "克拉科夫": "波兰", "罗兹": "波兰", "弗罗茨瓦夫": "波兰", "波兹南": "波兰",
+            "格但斯克": "波兰", "什切青": "波兰", "比得哥什": "波兰", "卢布林": "波兰", "卡托维兹": "波兰",
+            "白雅斯托克": "波兰", "格丁尼亚": "波兰", "琴斯托霍瓦": "波兰", "拉多姆": "波兰", "索斯诺维茨": "波兰",
+            "托伦": "波兰", "基尔采": "波兰", "格利维采": "波兰", "扎布热": "波兰", "比托姆": "波兰",
+            "奥斯威辛": "波兰", "马尔堡": "波兰", "扎科帕内": "波兰", "维利奇卡": "波兰", "弗罗茨瓦夫": "波兰",
+            # 斯洛伐克
+            "布拉迪斯拉发": "斯洛伐克", "科希策": "斯洛伐克", "普雷绍夫": "斯洛伐克", "日利纳": "斯洛伐克", "班斯卡比斯特里察": "斯洛伐克",
+            "尼特拉": "斯洛伐克", "特伦钦": "斯洛伐克", "马丁": "斯洛伐克", "特尔纳瓦": "斯洛伐克", "波普拉德": "斯洛伐克",
+            "普里维德扎": "斯洛伐克", "兹沃伦": "斯洛伐克", "巴尔代约夫": "斯洛伐克", "列沃恰": "斯洛伐克", "斯皮什斯基堡": "斯洛伐克",
+            # 斯洛文尼亚
+            "卢布尔雅那": "斯洛文尼亚", "马里博尔": "斯洛文尼亚", "采列": "斯洛文尼亚", "克拉尼": "斯洛文尼亚", "韦莱涅": "斯洛文尼亚",
+            "新戈里察": "斯洛文尼亚", "科佩尔": "斯洛文尼亚", "诺沃梅斯托": "斯洛文尼亚", "卡姆尼克": "斯洛文尼亚", "多姆扎勒": "斯洛文尼亚",
+            "布莱德": "斯洛文尼亚", "博希尼": "斯洛文尼亚", "皮兰": "斯洛文尼亚", "什科茨扬": "斯洛文尼亚", "波斯托伊纳": "斯洛文尼亚",
+            # 瑞士
+            "苏黎世": "瑞士", "日内瓦": "瑞士", "巴塞尔": "瑞士", "伯尔尼": "瑞士", "洛桑": "瑞士",
+            "圣加仑": "瑞士", "卢塞恩": "瑞士", "卢加诺": "瑞士", "比尔": "瑞士", "图恩": "瑞士",
+            "拉绍德封": "瑞士", "沙夫豪森": "瑞士", "弗里堡": "瑞士", "韦维": "瑞士", "拉佩斯": "瑞士",
+            "因特拉肯": "瑞士", "采尔马特": "瑞士", "格林德瓦": "瑞士", "少女峰": "瑞士", "马特洪峰": "瑞士",
+            "圣莫里茨": "瑞士", "洛伊克巴德": "瑞士", "安德马特": "瑞士", "文根": "瑞士", "拉克斯": "瑞士",
+            # === 北欧 ===
+            # 瑞典
+            "斯德哥尔摩": "瑞典", "哥德堡": "瑞典", "马尔默": "瑞典", "乌普萨拉": "瑞典", "林雪平": "瑞典",
+            "韦斯特罗斯": "瑞典", "厄勒布鲁": "瑞典", "北雪平": "瑞典", "赫尔辛堡": "瑞典", "永雪平": "瑞典",
+            "松兹瓦尔": "瑞典", "于默奥": "瑞典", "韦克舍": "瑞典", "加夫勒": "瑞典", "博罗斯": "瑞典",
+            "法伦": "瑞典", "卡尔斯塔德": "瑞典", "卡尔马": "瑞典", "维斯比": "瑞典", "基律纳": "瑞典",
+            # 挪威
+            "奥斯陆": "挪威", "卑尔根": "挪威", "特隆赫姆": "挪威", "斯塔万格": "斯洛文尼亚", "克里斯蒂安桑": "挪威",
+            "腓特烈斯塔": "挪威", "德拉门": "挪威", "谢恩": "挪威", "桑内斯": "挪威", "萨尔普斯堡": "挪威",
+            "特洛姆瑟": "挪威", "博多": "挪威", "阿尔塔": "挪威", "哈默菲斯特": "挪威", "纳尔维克": "挪威",
+            "弗洛姆": "挪威", "盖朗厄尔": "挪威", "奥勒松": "挪威", "利勒哈默尔": "挪威", "罗弗敦群岛": "挪威",
+            # 丹麦
+            "哥本哈根": "丹麦", "奥胡斯": "丹麦", "欧登塞": "丹麦", "奥尔堡": "丹麦", "埃斯比约": "丹麦",
+            "兰德斯": "丹麦", "科尔丁": "丹麦", "赫尔辛格": "丹麦", "马里布": "丹麦", "海勒鲁普": "丹麦",
+            "比隆": "丹麦", "希勒勒": "丹麦", "罗斯基勒": "丹麦", "斯卡恩": "丹麦", "法尔瑟特": "丹麦",
+            # 芬兰
+            "赫尔辛基": "芬兰", "埃斯波": "芬兰", "坦佩雷": "芬兰", "万塔": "芬兰", "图尔库": "芬兰",
+            "奥卢": "芬兰", "拉赫蒂": "芬兰", "库奥皮奥": "芬兰", "约恩苏": "芬兰", "约瓦斯屈莱": "芬兰",
+            "拉彭兰塔": "芬兰", "科特卡": "芬兰", "瓦萨": "芬兰", "弗绍": "芬兰", "海门林纳": "芬兰",
+            "罗瓦涅米": "芬兰", "凯米": "芬兰", "托尔尼奥": "芬兰", "萨利色尔卡": "芬兰", "伊瓦洛": "芬兰",
+            # 冰岛
+            "雷克雅未克": "冰岛", "科帕沃古尔": "冰岛", "哈夫纳夫约杜尔": "冰岛", "阿克雷里": "冰岛", "雷克雅内斯": "冰岛",
+            "塞尔福斯": "冰岛", "韦斯特曼纳群岛": "冰岛", "胡萨维克": "冰岛", "埃伊尔斯塔济": "冰岛", "凯夫拉维克": "冰岛",
+            # === 东欧 ===
+            # 俄罗斯（欧洲部分）
+            "莫斯科": "俄罗斯", "圣彼得堡": "俄罗斯", "下诺夫哥罗德": "俄罗斯", "喀山": "俄罗斯", "萨马拉": "俄罗斯",
+            "伏尔加格勒": "俄罗斯", "罗斯托夫": "俄罗斯", "乌法": "俄罗斯", "彭萨": "俄罗斯", "雅罗斯拉夫": "俄罗斯",
+            "卡卢加": "俄罗斯", "图拉": "俄罗斯", "弗拉基米尔": "俄罗斯", "苏兹达尔": "俄罗斯", "谢尔盖夫": "俄罗斯",
+            # 乌克兰
+            "基辅": "乌克兰", "哈尔科夫": "乌克兰", "敖德萨": "乌克兰", "第聂伯": "乌克兰", "顿涅茨克": "乌克兰",
+            "扎波罗热": "乌克兰", "利沃夫": "乌克兰", "克里沃罗格": "乌克兰", "尼古拉耶夫": "乌克兰", "马里乌波尔": "乌克兰",
+            "卢甘斯克": "乌克兰", "文尼察": "乌克兰", "赫尔松": "乌克兰", "切尔卡瑟": "乌克兰", "切尔尼戈夫": "乌克兰",
+            # 白俄罗斯
+            "明斯克": "白俄罗斯", "戈梅利": "白俄罗斯", "莫吉廖夫": "白俄罗斯", "维帖布斯克": "白俄罗斯", "格罗德诺": "白俄罗斯",
+            "布列斯特": "白俄罗斯", "鲍里索夫": "白俄罗斯", "巴拉诺维奇": "白俄罗斯", "平斯克": "白俄罗斯", "奥尔沙": "白俄罗斯",
+            # 波罗的海三国
+            "里加": "拉脱维亚", "陶格夫匹尔斯": "拉脱维亚", "利耶帕亚": "拉脱维亚", "叶尔加瓦": "拉脱维亚", "文茨皮尔斯": "拉脱维亚",
+            "塔林": "爱沙尼亚", "塔尔图": "爱沙尼亚", "纳尔瓦": "爱沙尼亚", "帕尔努": "爱沙尼亚", "科赫特拉": "爱沙尼亚",
+            "维尔纽斯": "立陶宛", "考纳斯": "立陶宛", "克莱佩达": "立陶宛", "希奥利艾": "立陶宛", "帕内韦日斯": "立陶宛",
+            # 摩尔多瓦
+            "基希讷乌": "摩尔多瓦", "蒂拉斯波尔": "摩尔多瓦", "巴尔济": "摩尔多瓦", "本德尔": "摩尔多瓦", "雷布尼察": "摩尔多瓦",
+            # === 巴尔干半岛 ===
+            # 克罗地亚
+            "萨格勒布": "克罗地亚", "斯普利特": "克罗地亚", "里耶卡": "克罗地亚", "奥西耶克": "克罗地亚", "扎达尔": "克罗地亚",
+            "普拉": "克罗地亚", "杜布罗夫尼克": "克罗地亚", "希贝尼克": "克罗地亚", "卡尔洛瓦茨": "克罗地亚", "瓦拉日丁": "克罗地亚",
+            "罗维尼": "克罗地亚", "波雷奇": "克罗地亚", "特罗吉尔": "克罗地亚", "赫瓦尔": "克罗地亚", "科尔丘拉": "克罗地亚",
+            # 塞尔维亚
+            "贝尔格莱德": "塞尔维亚", "诺维萨德": "塞尔维亚", "尼什": "塞尔维亚", "克拉古耶瓦茨": "塞尔维亚", "苏博蒂察": "塞尔维亚",
+            "潘切沃": "塞尔维亚", "泽蒙": "塞尔维亚", "莱斯科瓦茨": "塞尔维亚", "恰恰克": "塞尔维亚", "新帕扎尔": "塞尔维亚",
+            # 波黑
+            "萨拉热窝": "波黑", "巴尼亚卢卡": "波黑", "图兹拉": "波黑", "泽尼察": "波黑", "莫斯塔尔": "波黑",
+            "比哈奇": "波黑", "布里耶利纳": "波黑", "多博伊": "波黑", "格拉迪什卡": "波黑", "利夫诺": "波黑",
+            # 黑山
+            "波德戈里察": "黑山", "尼克希奇": "黑山", "普里耶波列": "黑山", "比耶洛波列": "黑山", "采蒂涅": "黑山",
+            "布德瓦": "黑山", "科托尔": "黑山", "乌尔齐尼": "黑山", "赫尔采格诺维": "黑山", "巴尔": "黑山",
+            # 北马其顿
+            "斯科普里": "北马其顿", "库马诺沃": "北马其顿", "比托拉": "北马其顿", "普里莱普": "北马其顿", "特托沃": "北马其顿",
+            "韦莱斯": "北马其顿", "什蒂普": "北马其顿", "奥赫里德": "北马其顿", "戈斯蒂瓦尔": "北马其顿", "斯特鲁加": "北马其顿",
+            # 阿尔巴尼亚
+            "地拉那": "阿尔巴尼亚", "都拉斯": "阿尔巴尼亚", "埃尔巴桑": "阿尔巴尼亚", "发罗拉": "阿尔巴尼亚", "斯库台": "阿尔巴尼亚",
+            "科尔察": "阿尔巴尼亚", "卢什涅": "阿尔巴尼亚", "费里": "阿尔巴尼亚", "贝拉特": "阿尔巴尼亚", "吉诺卡斯特": "阿尔巴尼亚",
+            # 保加利亚
+            "索菲亚": "保加利亚", "普罗夫迪夫": "保加利亚", "瓦尔纳": "保加利亚", "布尔加斯": "保加利亚", "鲁塞": "保加利亚",
+            "斯塔拉扎戈拉": "保加利亚", "普列文": "保加利亚", "슬리문": "保加利亚", "多布里奇": "保加利亚", "舒门": "保加利亚",
+            "帕扎尔吉克": "保加利亚", "哈斯科沃": "保加利亚", "扬博尔": "保加利亚", "布拉戈耶夫格勒": "保加利亚", "韦利科特尔诺沃": "保加利亚",
+            # 罗马尼亚
+            "布加勒斯特": "罗马尼亚", "克卢日": "罗马尼亚", "蒂米什瓦拉": "罗马尼亚", "雅西": "罗马尼亚", "康斯坦察": "罗马尼亚",
+            "克拉约瓦": "罗马尼亚", "布拉索夫": "罗马尼亚", "加拉茨": "罗马尼亚", "普洛耶什蒂": "罗马尼亚", "奥拉迪亚": "罗马尼亚",
+            "布勒伊拉": "罗马尼亚", "阿拉德": "罗马尼亚", "皮特什蒂": "罗马尼亚", "锡比乌": "罗马尼亚", "巴克乌": "罗马尼亚",
+            "锡纳亚": "罗马尼亚", "布兰": "罗马尼亚", "德古拉城堡": "罗马尼亚", "佩莱什城堡": "罗马尼亚", "马拉穆雷什": "罗马尼亚",
+            # 土耳其（欧洲部分）
+            "伊斯坦布尔": "土耳其", "埃迪尔内": "土耳其", "泰基尔达": "土耳其", "克尔克拉雷利": "土耳其", "恰纳卡莱": "土耳其",
+            # 塞浦路斯
+            "尼科西亚": "塞浦路斯", "利马索尔": "塞浦路斯", "拉纳卡": "塞浦路斯", "法马古斯塔": "塞浦路斯", "帕福斯": "塞浦路斯",
+            "凯里尼亚": "塞浦路斯", "阿依纳帕": "塞浦路斯", "普罗塔拉斯": "塞浦路斯", "特罗多斯": "塞浦路斯", "阿卡马斯": "塞浦路斯",
+            # 马耳他
+            "瓦莱塔": "马耳他", "斯利马": "马耳他", "圣朱利安斯": "马耳他", "姆西达": "马耳他", "维多利亚": "马耳他",
+            "马尔萨什洛克": "马耳他", "梅利哈": "马耳他", "戈佐": "马耳他", "蓝湖": "马耳他", "姆迪纳": "马耳他",
+        }
+        # 欧洲城市别名映射（包含各种表达方式）
+        self.european_city_aliases = {
+            # 英文名称映射
+            "paris": "巴黎", "rome": "罗马", "london": "伦敦", "berlin": "柏林",
+            "madrid": "马德里", "barcelona": "巴塞罗那", "vienna": "维也纳", "prague": "布拉格",
+            "amsterdam": "阿姆斯特丹", "florence": "佛罗伦萨", "venice": "威尼斯", "athens": "雅典",
+            "budapest": "布达佩斯", "lisbon": "里斯本", "stockholm": "斯德哥尔摩", "copenhagen": "哥本哈根",
+            "helsinki": "赫尔辛基", "oslo": "奥斯陆", "zurich": "苏黎世", "geneva": "日内瓦",
+            "munich": "慕尼黑", "milan": "米兰", "naples": "那不勒斯", "nice": "尼斯",
+            "edinburgh": "爱丁堡", "dublin": "都柏林", "brussels": "布鲁塞尔", "warsaw": "华沙",
+            "krakow": "克拉科夫", "zagreb": "萨格勒布", "belgrade": "贝尔格莱德", "sofia": "索菲亚",
+            "bucharest": "布加勒斯特", "kiev": "基辅", "moscow": "莫斯科", "st petersburg": "圣彼得堡",
+            "reykjavik": "雷克雅未克", "tallinn": "塔林", "riga": "里加", "vilnius": "维尔纽斯",
+            "bratislava": "布拉迪斯拉发", "ljubljana": "卢布尔雅那", "sarajevo": "萨拉热窝",
+            "dubrovnik": "杜布罗夫尼克", "split": "斯普利特", "santorini": "圣托里尼", "mykonos": "米科诺斯",
+            # 中文别名
+            "花都": "巴黎", "光之城": "巴黎", "永恒之城": "罗马", "雾都": "伦敦",
+            "音乐之都": "维也纳", "黄金城市": "布拉格", "千塔之城": "布拉格",
+            "运河之城": "阿姆斯特丹", "翡冷翠": "佛罗伦萨", "文艺复兴之都": "佛罗伦萨",
+            "水城": "威尼斯", "西方文明的摇篮": "雅典", "多瑙河明珠": "布达佩斯",
+            "七丘之城": "里斯本", "北方威尼斯": "斯德哥尔摩", "童话之都": "哥本哈根",
+            "波罗的海的女儿": "赫尔辛基", "欧洲屋脊": "因特拉肯", "北方雅典": "爱丁堡",
+            "翡翠岛": "都柏林", "欧洲之都": "布鲁塞尔", "高迪之城": "巴塞罗那",
+        }
+        # 中文数字映射（保持原有）
+        self.chinese_numbers = {
+            '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9, '十': 10,
+            '两': 2, '半': 0.5, '壹': 1, '贰': 2, '叁': 3, '肆': 4, '伍': 5, '陆': 6, '柒': 7, '捌': 8, '玖': 9, '拾': 10,
+            # 特殊时长表达
+            '半个月': 15, '一个月': 30, '半年': 180, '一年': 365,
+            '半天': 0.5, '一天': 1, '两天': 2, '三天': 3, '四天': 4, '五天': 5, '六天': 6, '七天': 7,
+            '八天': 8, '九天': 9, '十天': 10, '半周': 3.5, '一周': 7, '两周': 14,
+            # 假期相关
+            '小长假': 3, '长假': 7, '十一': 7, '国庆': 7, '春节': 7, '五一': 3, '清明': 3,
+            '端午': 3, '中秋': 3, '元旦': 3, '暑假': 60, '寒假': 30, '周末': 2, '长周末': 3
+        }
     def extract(self, user_message: str) -> dict:
+        """使用纯正则表达式提取结构化信息 - 聚焦欧洲"""
         # 输入验证
         if not user_message or not isinstance(user_message, str):
             log.warning("⚠️ 收到无效的用户消息")
             return {}
+        if len(user_message.strip()) < 2:
+            log.warning("⚠️ 用户消息过短，跳过信息提取")
+            return {}
+        log.info("🛠️ 使用正则表达式提取信息（聚焦欧洲）")
+        result = {}
+        # 1. 提取目的地信息
+        destination_info = self._extract_european_destination(user_message)
+        if destination_info:
+            result["destination"] = destination_info
+        # 2. 提取时长信息
+        duration_info = self._extract_duration(user_message)
+        if duration_info:
+            result["duration"] = duration_info
+        # 3. 提取预算信息
+        budget_info = self._extract_budget(user_message)
+        if budget_info:
+            result["budget"] = budget_info
+        log.info(f"📊 欧���城市正则提取结果: {result}")
+        return result
+    def _extract_european_destination(self, text: str) -> dict:
+        """提取欧洲目的地信息 - 专门针对欧洲城市"""
         result = {}
+        # 目的地提取模式（复用之前的完整模式）
+        destination_patterns = [
+            # 基本动词 + 地点
+            r'去(\w+)', r'到(\w+)', r'想去(\w+)', r'前往(\w+)', r'计划去(\w+)', r'打算去(\w+)',
+            r'准备去(\w+)', r'希望去(\w+)', r'考虑去(\w+)', r'决定去(\w+)', r'选择去(\w+)',
+            r'旅行(\w+)', r'游(\w+)', r'玩(\w+)', r'访问(\w+)', r'探索(\w+)', r'体验(\w+)',
+            r'出发去(\w+)', r'飞去(\w+)', r'飞往(\w+)', r'飞到(\w+)', r'坐车去(\w+)', r'开车去(\w+)',
+            # 目的地关键词
+            r'目的地[\s是：:]*(\w+)', r'地方[\s是：:]*(\w+)', r'城市[\s是：:]*(\w+)',
+            r'国家[\s是：:]*(\w+)', r'地区[\s是：:]*(\w+)', r'景点[\s是：:]*(\w+)',
+            # 在某地表达
+            r'在(\w+)旅游', r'在(\w+)游玩', r'在(\w+)度假', r'在(\w+)旅行', r'在(\w+)玩',
+            r'在(\w+)观光', r'在(\w+)游览', r'在(\w+)休假', r'在(\w+)放松', r'在(\w+)散心',
+            # 某地 + 行程/之旅
+            r'(\w+)之旅', r'(\w+)行程', r'(\w+)旅程', r'(\w+)游', r'(\w+)行', r'(\w+)之行',
+            r'(\w+)深度游', r'(\w+)自由行', r'(\w+)跟团游', r'(\w+)自驾游', r'(\w+)蜜月游',
+            # 包含"的"的表达
+            r'(\w+)的旅行', r'(\w+)的行程', r'(\w+)的攻略', r'(\w+)的景点', r'(\w+)的美食',
+            r'(\w+)的文化', r'(\w+)的历史', r'(\w+)的风景', r'(\w+)的特色', r'(\w+)的魅力',
+            # 特殊交通方式表达
+            r'飞(\w+)', r'坐船去(\w+)', r'坐火车去(\w+)', r'自驾去(\w+)', r'徒步去(\w+)',
+            r'骑行去(\w+)', r'背包去(\w+)', r'穷游去(\w+)',
+            # 旅行类型 + 地点
+            r'自由行(\w+)', r'跟团(\w+)', r'自驾(\w+)', r'蜜月(\w+)', r'毕业(\w+)',
+            r'亲子(\w+)', r'家庭(\w+)', r'情侣(\w+)', r'闺蜜(\w+)', r'独自(\w+)',
+            # 度假/休闲表达
+            r'度假去(\w+)', r'休闲去(\w+)', r'放松去(\w+)', r'散心去(\w+)', r'疗养去(\w+)',
+            # 其他变体
+            r'想要去(\w+)', r'渴望去(\w+)', r'梦想去(\w+)', r'向往(\w+)', r'憧憬(\w+)',
+            r'安排去(\w+)', r'规划去(\w+)', r'预定(\w+)', r'订(\w+)的票', r'买(\w+)机票'
+        ]
+        # 尝试所有模式
+        for pattern in destination_patterns:
+            matches = re.findall(pattern, text)
+            for match in matches:
+                city_name = match.strip()
+                # 首先检查别名映射
+                if city_name.lower() in self.european_city_aliases:
+                    city_name = self.european_city_aliases[city_name.lower()]
+                elif city_name in self.european_city_aliases:
+                    city_name = self.european_city_aliases[city_name]
+                # 验证是否为欧洲城市
+                if self._is_valid_european_city(city_name):
+                    result["name"] = city_name
+                    # 查找对应国家
+                    if city_name in self.european_cities:
+                        result["country"] = self.european_cities[city_name]
+                    break
+            if result:
+                break
+        # 特殊处理：国家+城市的组合（欧洲专用）
+        european_country_city_patterns = [
+            r'(\w+)的(\w+)', r'(\w+)(\w+)市', r'(\w+)(\w+)府',
+            r'(\w+)(\w+)州', r'(\w+)(\w+)省', r'(\w+)(\w+)岛'
         ]
+        if not result:
+            for pattern in european_country_city_patterns:
+                matches = re.findall(pattern, text)
+                for country, city in matches:
+                    # 检查是否是已知的欧洲国家-城市组合
+                    if city in self.european_cities and self.european_cities[city] == country:
+                        result["name"] = city
+                        result["country"] = country
+                        break
+                    elif self._is_valid_european_country(country) and self._is_valid_european_city(city):
+                        result["name"] = city
+                        result["country"] = country
+                        break
+                if result:
                     break
+        return result
+    def _extract_duration(self, text: str) -> dict:
+        """提取时长信息 - 完整保留之前的实现"""
+        result = {}
+        # 天数提取模式 - 大幅扩展（保持原有完整实现）
         day_patterns = [
+            # 基本数字+天
+            r'(\d+)天', r'(\d+)日', r'(\d+)号', r'(\d+)个天', r'(\d+)个日',
+            # 动词+天数
+            r'玩(\d+)天', r'住(\d+)天', r'呆(\d+)天', r'待(\d+)天', r'停留(\d+)天',
+            r'逗留(\d+)天', r'游(\d+)天', r'旅行(\d+)天', r'度假(\d+)天', r'休假(\d+)天',
+            # 行程相关
+            r'(\d+)天行程', r'(\d+)天旅程', r'(\d+)天旅行', r'(\d+)天游', r'(\d+)天之旅',
+            r'(\d+)天的行程', r'(\d+)天的旅程', r'(\d+)天的旅行', r'(\d+)天的假期',
+            r'行程(\d+)天', r'旅程(\d+)天', r'假期(\d+)天', r'休假(\d+)天',
+            # 时间修饰词
+            r'大概(\d+)天', r'约(\d+)天', r'差不多(\d+)天', r'左右(\d+)天', r'上下(\d+)天',
+            r'最多(\d+)天', r'最少(\d+)天', r'至少(\d+)天', r'不超过(\d+)天', r'超过(\d+)天',
+            r'将近(\d+)天', r'接近(\d+)天', r'快(\d+)天', r'足足(\d+)天', r'整整(\d+)天',
+            # 周相关
+            r'(\d+)周', r'(\d+)个周', r'(\d+)星期', r'(\d+)个星期', r'(\d+)礼拜', r'(\d+)个礼拜',
+            r'玩(\d+)周', r'住(\d+)周', r'呆(\d+)周', r'待(\d+)周', r'旅行(\d+)周',
+            r'(\d+)周的行程', r'(\d+)星期的旅行', r'(\d+)个礼拜的假期',
+            # 月相关
+            r'(\d+)月', r'(\d+)个月', r'(\d+)个月份',
+            r'玩(\d+)个月', r'住(\d+)个月', r'旅行(\d+)个月', r'度假(\d+)个月',
+            r'(\d+)个月的行程', r'(\d+)月的旅行', r'(\d+)个月的假期',
+            # 范围表达
+            r'(\d+)-(\d+)天', r'(\d+)到(\d+)天', r'(\d+)至(\d+)天', r'(\d+)~(\d+)天',
+            r'(\d+)天到(\d+)天', r'从(\d+)天到(\d+)天', r'介于(\d+)到(\d+)天',
+            # 中文数字
+            r'一天', r'二天', r'三天', r'四天', r'五天', r'六天', r'七天', r'八天', r'九天', r'十天',
+            r'两天', r'俩天', r'仨天', r'半天', r'一天半', r'两天半', r'三天半',
+            r'十一天', r'十二天', r'十三天', r'十四天', r'十五天', r'二十天', r'三十天',
+            # 特殊时长表达
+            r'周末', r'长周末', r'小长假', r'长假', r'黄金周', r'假期',
+            r'十一', r'国庆', r'春节', r'过年', r'五一', r'劳动节', r'清明', r'端午', r'中秋', r'元旦',
+            r'暑假', r'寒假', r'年假', r'蜜月', r'度蜜月',
+            r'短途', r'中途', r'长途', r'快闪', r'一日游', r'两日游', r'三日游', r'多日游'
         ]
+        # 尝试提取时长（完整保留原有逻辑）
         for pattern in day_patterns:
+            matches = re.findall(pattern, text)
+            for match in matches:
+                days = None
+                if isinstance(match, tuple):
+                    # 范围表达，取平均值
+                    try:
+                        start_days = int(match[0])
+                        end_days = int(match[1])
+                        days = (start_days + end_days) / 2
+                    except:
+                        days = int(match[0]) if match[0].isdigit() else None
+                elif match.isdigit():
+                    days = int(match)
+                    # 处理单位转换
+                    if '周' in pattern or '星期' in pattern or '礼拜' in pattern:
+                        days *= 7
+                    elif '月' in pattern:
+                        days *= 30
+                # 处理中文数字和特殊表达
+                elif match in self.chinese_numbers:
+                    days = self.chinese_numbers[match]
+                # 验证天数合理性
+                if days and 0.5 <= days <= 365:
+                    result["days"] = int(days) if days >= 1 else days
+                    # 添加描��信息
+                    if days <= 1:
+                        result["description"] = "当日往返"
+                    elif days <= 3:
+                        result["description"] = "短途旅行"
+                    elif days <= 7:
+                        result["description"] = "一周内旅行"
+                    elif days <= 14:
+                        result["description"] = "中长途旅行"
+                    elif days <= 30:
+                        result["description"] = "长途旅行"
+                    else:
+                        result["description"] = "超长途旅行"
+                    # 保留原始匹配文本作为额外描述
+                    if not isinstance(match, tuple) and not match.isdigit():
+                        result["description"] = match
                     break
+            if result:
+                break
+        return result
+    def _extract_budget(self, text: str) -> dict:
+        """提取预算信息 - 针对欧洲旅行优化"""
+        result = {}
+        text_lower = text.lower()
+        # 欧洲旅行常用货币的金额提取模式
+        amount_patterns = [
+            # === 欧元表达 - 优先级最高（欧洲旅行主要货币） ===
+            r'(\d+)欧元', r'(\d+)欧', r'€(\d+)', r'EUR(\d+)', r'eur(\d+)',
+            r'(\d+)euro', r'(\d+)Euro', r'(\d+)EURO',
+            r'(\d+\.?\d*)欧元', r'€(\d+\.?\d*)',
+            r'预算(\d+)欧', r'花费(\d+)欧', r'大概(\d+)欧', r'约(\d+)欧',
+            # === 人民币表达 ===
+            r'(\d+)元', r'(\d+)块', r'(\d+)块钱', r'(\d+)人民币', r'(\d+)rmb', r'(\d+)RMB',
+            r'¥(\d+)', r'￥(\d+)', r'CNY(\d+)', r'cny(\d+)',
+            # === 美元表达 ===
+            r'(\d+)美元', r'(\d+)美刀', r'(\d+)刀', r'\$(\d+)', r'USD(\d+)', r'usd(\d+)',
+            r'(\d+)dollar', r'(\d+)Dollar',
+            # === 英镑表达（英国旅行） ===
+            r'(\d+)英镑', r'(\d+)镑', r'£(\d+)', r'GBP(\d+)', r'gbp(\d+)',
+            r'(\d+)pound', r'(\d+)Pound',
+            # === 瑞士法郎（瑞士旅行） ===
+            r'(\d+)瑞士法郎', r'(\d+)法郎', r'CHF(\d+)', r'chf(\d+)',
+            r'(\d+)瑞郎', r'(\d+)swiss franc',
+            # === 预算相关表达 ===
+            r'预算(\d+)', r'预算是(\d+)', r'预算大概(\d+)', r'预算约(\d+)',
+            r'预算差不多(\d+)', r'预算在(\d+)', r'预算控制在(\d+)',
+            r'预算不超过(\d+)', r'预算最多(\d+)', r'预算最少(\d+)',
+            # === 花费相关表达 ===
+            r'花(\d+)', r'花费(\d+)', r'花销(\d+)', r'开销(\d+)', r'支出(\d+)',
+            r'费用(\d+)', r'成本(\d+)', r'总共(\d+)', r'一共(\d+)', r'总计(\d+)',
+            # === 万元表达 ===
+            r'(\d+)万', r'(\d+)万元', r'(\d+)万块', r'(\d+)万人民币',
+            r'(\d+)万欧', r'(\d+)万欧元', r'(\d+)万美元', r'(\d+)万英镑',
+            r'(\d+\.?\d*)万', r'(\d+\.?\d*)万元',
+            # === 千元表达 ===
+            r'(\d+)千', r'(\d+)千元', r'(\d+)千块', r'(\d+)k', r'(\d+)K',
+            r'(\d+)千欧', r'(\d+)千美元', r'(\d+)千英镑',
+            # === 范围表达 ===
+            r'(\d+)-(\d+)', r'(\d+)到(\d+)', r'(\d+)至(\d+)', r'(\d+)~(\d+)',
+            r'(\d+)左右', r'约(\d+)', r'差不多(\d+)', r'大概(\d+)',
+            # === 每人/每天相关 ===
+            r'每人(\d+)', r'人均(\d+)', r'单人(\d+)', r'每天(\d+)', r'日均(\d+)',
+            # === 中文数字金额 ===
+            r'一万', r'两万', r'三万', r'四万', r'五万', r'六万', r'七万', r'八万', r'九万', r'十万',
+            r'一千', r'两千', r'三千', r'四千', r'五千', r'六千', r'七千', r'八千', r'九千'
         ]
+        # 中文数字金额映射
+        chinese_money = {
+            '一万': 10000, '两万': 20000, '三万': 30000, '四万': 40000, '五万': 50000,
+            '六万': 60000, '七万': 70000, '八万': 80000, '九万': 90000, '十万': 100000,
+            '一千': 1000, '两千': 2000, '三千': 3000, '四千': 4000, '五千': 5000,
+            '六千': 6000, '七��': 7000, '八千': 8000, '九千': 9000
+        }
+        # 尝试提取金额
+        for pattern in amount_patterns:
+            matches = re.findall(pattern, text)
+            for match in matches:
+                amount = None
+                currency = "RMB"  # 默认货币
+                if isinstance(match, tuple):
+                    # 处理范围或多个捕获组
+                    if len(match) == 2 and all(m.replace('.','').isdigit() for m in match if m):
+                        try:
+                            amount = (float(match[0]) + float(match[1])) / 2
+                        except:
+                            amount = float(match[0]) if match[0].replace('.','').isdigit() else float(match[1])
+                    else:
+                        for m in match:
+                            if m and m.replace('.','').isdigit():
+                                amount = float(m)
+                                break
+                else:
+                    if match in chinese_money:
+                        amount = chinese_money[match]
+                    elif match.replace('.','').isdigit():
+                        amount = float(match)
+                if amount and amount > 0:
+                    # 处理单位转换
+                    if '万' in pattern:
+                        amount *= 10000
+                    elif '千' in pattern or 'k' in pattern.lower():
+                        amount *= 1000
+                    result["amount"] = int(amount)
+                    # 确定货币类型（针对欧洲旅行优化）
+                    if any(keyword in pattern for keyword in ['欧元', '欧', '€', 'eur', 'euro']):
+                        result["currency"] = "EUR"
+                    elif any(keyword in pattern for keyword in ['英镑', '镑', '£', 'gbp', 'pound']):
+                        result["currency"] = "GBP"
+                    elif any(keyword in pattern for keyword in ['瑞士法郎', '法郎', '瑞郎', 'chf', 'swiss franc']):
+                        result["currency"] = "CHF"
+                    elif any(keyword in pattern for keyword in ['美元', '美刀', '刀',  'usd', 'dollar']):
+                        result["currency"] = "USD"
+                    else:
+                        result["currency"] = "RMB"
+                    break
+            if result.get("amount"):
                 break
+        # 预算类型识别 - 针对欧洲旅行优化
         budget_type_keywords = {
+            'economy': [
+                # 经济相关
+                '经济', '便宜', '省钱', '实惠', '节省', '穷游', '学生', '青年',
+                '预算有限', '钱不多', '不贵', '划算', '性价比', '背包客',
+                '简单', '基础', '低成本', '节约', '省着花', '紧巴巴',
+                # 欧洲特色经济住宿
+                '青年旅社', '青旅', 'hostel', '民宿', 'airbnb', '客栈',
+                '多人间', '床位', '宿舍', '胶囊', 'capsule',
+                # 欧洲经济交通
+                '大巴', '长途汽车', 'flixbus', '火车', '二等座', '经济舱',
+                '欧洲通票', '青年票', '学生票', '团体票',
+                # 经济餐饮
+                '自己做饭', '超市', '便利店', '快餐', '街头小吃', '外卖',
+                '麦当劳', '汉堡王', 'kebab', 'döner'
+            ],
+            'comfortable': [
+                # 舒适相关
+                '舒适', '中等', '适中', '一般', '标准', '普通', '正常', '常规',
+                '中档', '中级', '合理', '平均', '中间档次', '不高不低',
+                # 欧洲中档住宿
+                '三星', '四星', '酒店', 'hotel', '标间', '双人间', '大床房',
+                '民宿', 'apartment', '公寓', 'b&b', 'pension',
+                # 欧洲舒适交通
+                '火车', '一等座', '高铁', 'tgv', 'ice', '城际列车',
+                '租车', '自驾', '商务舱', '直飞',
+                # 中档餐饮
+                '餐厅', '当地菜', '特色菜', '中档餐厅', '酒吧', 'bistro'
+            ],
+            'luxury': [
+                # 奢华相关
+                '豪华', '奢华', '高端', '顶级', '精品', '奢侈', '贵族',
+                '贵一点', '不差钱', '任性', '土豪', '有钱', '不在乎钱',
+                '高消费', '享受', '奢享', '尊贵', '至尊', 'VIP',
+                # 欧洲豪华住宿
+                '五星', '六星', '豪华酒店', 'luxury hotel', '度假村', 'resort',
+                '别墅', 'villa', '城堡', 'castle', '套房', 'suite', '总统套房',
+                '丽思卡���顿', '四季', '文华东方', '半岛', '香格里拉', '希尔顿',
+                'ritz carlton', 'four seasons', 'mandarin oriental', 'peninsula',
+                # 豪华交通
+                '头等舱', '商务舱', '私人飞机', 'private jet', '豪车', '奔驰', '宝马',
+                '奥迪', '保时捷', '法拉利', '兰博基尼', 'mercedes', 'bmw', 'audi',
+                # 奢华服务
+                '私人导游', '管家服务', 'concierge', '司机', '专车', '包车',
+                '定制旅行', '私人订制', '一对一服务', 'vip通道',
+                # 高端餐饮
+                '米其林', 'michelin', '米其林三星', '米其林餐厅', '高档餐厅',
+                '法式大餐', '意式料理', '分子料理', '酒庄', 'wine tasting'
+            ]
         }
+        # 识别预算类型
         for budget_type, keywords in budget_type_keywords.items():
+            matched_keywords = [kw for kw in keywords if kw in text_lower]
+            if matched_keywords:
+                result["type"] = budget_type
+                result["description"] = matched_keywords[0]
                 break
+        # 如果有金额但没有类型，根据金额和货币推断类型（欧洲标准）
+        if result.get("amount") and not result.get("type"):
+            amount = result["amount"]
+            currency = result.get("currency", "RMB")
+            # 根据欧洲旅行成本设置阈值
+            if currency == "EUR":
+                if amount < 50:  # 每天50欧以下
+                    result["type"] = "economy"
+                    result["description"] = "经济预算"
+                elif amount < 150:  # 每天50-150欧
+                    result["type"] = "comfortable"
+                    result["description"] = "舒适预算"
+                else:  # 每天150欧以上
+                    result["type"] = "luxury"
+                    result["description"] = "豪华预算"
+            elif currency == "GBP":
+                if amount < 40:  # 每天40英镑以下
+                    result["type"] = "economy"
+                    result["description"] = "经济预算"
+                elif amount < 120:  # 每天40-120英镑
+                    result["type"] = "comfortable"
+                    result["description"] = "舒适预算"
+                else:  # 每天120英镑以上
+                    result["type"] = "luxury"
+                    result["description"] = "豪华预算"
+            elif currency == "CHF":
+                if amount < 60:  # 每天60瑞郎以下
+                    result["type"] = "economy"
+                    result["description"] = "经济预算"
+                elif amount < 180:  # 每天60-180瑞郎
+                    result["type"] = "comfortable"
+                    result["description"] = "舒适预算"
+                else:  # 每天180瑞郎以上
+                    result["type"] = "luxury"
+                    result["description"] = "豪华预算"
+            elif currency == "RMB":
+                if amount < 300:  # 每天300元以下
+                    result["type"] = "economy"
+                    result["description"] = "经济预算"
+                elif amount < 800:  # 每天300-800元
+                    result["type"] = "comfortable"
+                    result["description"] = "舒适预算"
+                else:  # 每天800元以上
+                    result["type"] = "luxury"
+                    result["description"] = "豪华预算"
+            elif currency == "USD":
+                if amount < 60:  # 每天60美元以下
+                    result["type"] = "economy"
+                    result["description"] = "经济预算"
+                elif amount < 150:  # 每天60-150美元
+                    result["type"] = "comfortable"
+                    result["description"] = "舒适预算"
+                else:  # 每天150美元以上
+                    result["type"] = "luxury"
+                    result["description"] = "豪华预算"
         return result
+    def _is_valid_european_city(self, name: str) -> bool:
+        """验证是否为有效的欧洲城市名称"""
+        if not name or len(name) < 1:
+            return False
+        # 排除数字和常见的非地名词汇
+        invalid_words = [
+            # 数字和时间
+            '天', '日', '号', '月', '年', '周', '小时', '分钟', '秒',
+            # 金钱相关
+            '元', '块', '钱', '万', '千', '百', '预算', '费用', '成本', '价格',
+            '美元', '欧元', '英镑', '瑞郎', '法郎',
+            # 旅行相关动词
+            '花', '费', '旅行', '旅游', '行程', '计划', '想', '去', '到', '的',
+            '在', '是', '个', '了', '和', '与', '或', '但', '而', '就', '都',
+            # 其他常见词
+            '人', '我', '你', '他', '她', '们', '这', '那', '什么', '怎么',
+            '好', '很', '非常', '特别', '大', '小', '新', '老'
+        ]
+        if name.isdigit() or name in invalid_words:
+            return False
+        # 检查是否包含数字（地名通常不包含数字）
+        if any(char.isdigit() for char in name):
+            return False
+        # 检查是否在欧洲城市列表中
+        if name in self.european_cities:
+            return True
+        # 检查是否在别名列表中
+        if name in self.european_city_aliases or name.lower() in self.european_city_aliases:
+            return True
+        # 城市名称长度检查
+        if len(name) > 15:
+            return False
+        # 检查是否包含特殊字符
+        if any(char in name for char in '!@#$%^&*()+={}[]|\\:";\'<>?,.`~'):
+            return False
+        return False  # 只接受明确在欧洲城市列表中的城市
+    def _is_valid_european_country(self, name: str) -> bool:
+        """验证是否为有效的欧洲国家名称"""
+        if not name or len(name) < 2:
+            return False
+        # 欧洲国家列表
+        european_countries = {
+            # 西欧
+            '法国', '德国', '英国', '荷兰', '比利时', '卢森堡',
+            # 南欧
+            '意大利', '西班牙', '葡萄牙', '希腊', '马耳他', '塞浦路斯',
+            # 中欧
+            '奥地利', '瑞士', '捷克', '斯洛伐克', '匈牙利', '波兰', '斯洛文尼亚',
+            # 北欧
+            '瑞典', '挪威', '丹麦', '芬兰', '冰岛',
+            # 东欧
+            '俄罗斯', '乌克兰', '白俄罗斯', '立陶宛', '拉脱维亚', '爱沙尼亚', '摩尔多瓦',
+            # 巴尔干半岛
+            '克罗地亚', '塞尔维亚', '波黑', '黑山', '北马其顿', '阿尔巴尼亚',
+            '保加利亚', '罗马尼亚', '土耳其'
+        }
+        return name in european_countries
+    # 保持向后兼容的验证方法
+    def _validate_and_normalize(self, data: dict) -> dict:
+        """验证和规范化数据"""
+        return data

modules/knowledge_base.py CHANGED Viewed

@@ -6,24 +6,283 @@ from utils.logger import log
 class KnowledgeBase:
     def __init__(self, file_path: Path = Path("./config/general_travelplan.json")):
         self.knowledge = []
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                self.knowledge = json.load(f).get('clean_knowledge', [])
-            log.info(f"✅ 知识库加载完成")
-        except Exception as e:
-            log.error(f"❌ 知识库加载失败: {e}", exc_info=True)
-            raise
     def search(self, query: str) -> list:
         relevant_knowledge = []
         query_lower = query.lower()
-        for item in self.knowledge:
-            # 简单实现：如果查询的城市在知识库的目的地中，则返回该知识
-            destinations = item.get('knowledge', {}).get('travel_knowledge', {}).get('destination_info', {}).get('primary_destinations', [])
-            for dest in destinations:
-                if dest.lower() in query_lower:
-                    if item not in relevant_knowledge:
-                        relevant_knowledge.append(item)
-                    break
         return relevant_knowledge

 class KnowledgeBase:
     def __init__(self, file_path: Path = Path("./config/general_travelplan.json")):
         self.knowledge = []
+        self.city_index = {}  # 城市索引
+        self.country_index = {}  # 国家索引
+        self.region_index = {}  # 地区索引
+        with open(file_path, 'r', encoding='utf-8') as f:
+            self.knowledge = json.load(f).get('clean_knowledge', [])
+        log.info(f"✅ 知识库加载完成")
+    def _build_indexes(self):
+        """建立快速检索索引"""
+        for idx, item in enumerate(self.knowledge):
+            knowledge = item.get('knowledge', {}).get('travel_knowledge', {})
+            if not knowledge:
+                continue
+            dest_info = knowledge.get('destination_info', {})
+            # 建立城市索引
+            primary_destinations = dest_info.get('primary_destinations', [])
+            for city in primary_destinations:
+                if city not in self.city_index:
+                    self.city_index[city] = []
+                self.city_index[city].append(idx)
+            # 建立国家索引
+            countries = dest_info.get('countries', [])
+            for country in countries:
+                if country not in self.country_index:
+                    self.country_index[country] = []
+                self.country_index[country].append(idx)
+            # 建立地区索引
+            region_type = dest_info.get('region_type', '')
+            if region_type:
+                if region_type not in self.region_index:
+                    self.region_index[region_type] = []
+                self.region_index[region_type].append(idx)
     def search(self, query: str) -> list:
+        """搜索知识库中的相关信息"""
         relevant_knowledge = []
         query_lower = query.lower()
+        log.info(f"🔍 在知识库中搜索: '{query}'")
+        # 1. 直接城市匹配
+        if query in self.city_index:
+            for idx in self.city_index[query]:
+                if self.knowledge[idx] not in relevant_knowledge:
+                    relevant_knowledge.append(self.knowledge[idx])
+            log.info(f"✅ 通过城市直接匹配找到 {len(self.city_index[query])} 条记录")
+        # 2. 国家匹配
+        matching_country = self._find_country_for_city(query)
+        if matching_country and matching_country in self.country_index:
+            for idx in self.country_index[matching_country]:
+                if self.knowledge[idx] not in relevant_knowledge:
+                    relevant_knowledge.append(self.knowledge[idx])
+            log.info(f"✅ 通过国家匹配({matching_country})找到额外记录")
+        # 3. 地区匹配
+        matching_region = self._find_region_for_city(query)
+        if matching_region and matching_region in self.region_index:
+            for idx in self.region_index[matching_region]:
+                if self.knowledge[idx] not in relevant_knowledge:
+                    relevant_knowledge.append(self.knowledge[idx])
+            log.info(f"✅ 通过地区匹配({matching_region})找到额外记录")
+        # 4. 模糊匹配
+        if not relevant_knowledge:
+            log.info("🔍 尝试模糊匹配...")
+            for item in self.knowledge:
+                knowledge = item.get('knowledge', {}).get('travel_knowledge', {})
+                dest_info = knowledge.get('destination_info', {})
+                # 检查所有目的地
+                primary_destinations = dest_info.get('primary_destinations', [])
+                for dest in primary_destinations:
+                    if query_lower in dest.lower() or dest.lower() in query_lower:
+                        if item not in relevant_knowledge:
+                            relevant_knowledge.append(item)
+                            log.info(f"✅ 模糊匹配找到: {dest}")
+                        break
+        log.info(f"📊 搜索完成，共找到 {len(relevant_knowledge)} 条相关记录")
         return relevant_knowledge
+    def _find_country_for_city(self, city_name: str) -> str:
+        """根据城市名查找所属国家"""
+        city_country_mapping = {
+            # 中欧
+            "布拉格": "捷克", "布尔诺": "捷克", "库特纳霍拉": "捷克",
+            "维也纳": "奥地利", "萨尔茨堡": "奥地利", "哈尔施塔特": "奥地利", "巴德伊舍": "奥地利",
+            "布达佩斯": "匈牙利", "德布勒森": "匈牙利", "圣安德烈": "匈牙利",
+            "布拉迪斯拉发": "斯洛伐克",
+            # 西欧
+            "巴黎": "法国", "里昂": "法国", "尼斯": "法国", "马赛": "法国",
+            "柏林": "德国", "慕尼黑": "德国", "汉堡": "德国", "科隆": "德国", "法兰克福": "德国",
+            "阿姆斯特丹": "荷兰", "鹿特丹": "荷兰", "海牙": "荷兰",
+            "布鲁塞尔": "比利时", "安特卫普": "比利时", "布吕赫": "比利时",
+            "卢森堡市": "卢森堡",
+            "苏黎世": "瑞士", "日内瓦": "瑞士", "因特拉肯": "瑞士",
+            # 南欧
+            "罗马": "意大利", "米兰": "意大利", "威尼斯": "意大利", "佛罗伦萨": "意大利",
+            "马德里": "西班牙", "巴塞罗那": "西班牙", "塞维利亚": "西班牙",
+            "里斯本": "葡萄牙", "波尔图": "葡萄牙",
+            "雅典": "希腊", "圣托里尼": "希腊", "米科诺斯": "希腊",
+            # 北欧
+            "斯德哥尔摩": "瑞典", "哥德堡": "瑞典",
+            "奥斯陆": "挪威", "卑尔根": "挪威",
+            "哥本哈根": "丹麦", "奥胡斯": "丹麦",
+            "赫尔辛基": "芬兰", "坦佩雷": "芬兰",
+            "雷克雅未克": "冰岛",
+            # 英国
+            "伦敦": "英国", "爱丁堡": "英国", "曼彻斯特": "英国",
+        }
+        return city_country_mapping.get(city_name, "")
+    def _find_region_for_city(self, city_name: str) -> str:
+        """根据城市名查找所属地区"""
+        city_region_mapping = {
+            # 中欧
+            "布拉格": "中欧", "布尔诺": "中欧", "库特纳霍拉": "中欧",
+            "维也纳": "中欧", "萨尔茨堡": "中欧", "哈尔施塔特": "中欧", "巴德伊舍": "中欧",
+            "布达佩斯": "中欧", "德布勒森": "中欧", "圣安德烈": "中欧",
+            "布拉迪斯拉发": "中欧",
+            # 西欧
+            "巴黎": "西欧", "里昂": "西欧", "尼斯": "西欧",
+            "柏林": "西欧", "慕尼黑": "西欧", "汉堡": "西欧",
+            "阿姆斯特丹": "西欧", "鹿特丹": "西欧",
+            "布鲁塞尔": "西欧", "安特卫普": "西欧",
+            "苏黎世": "西欧", "日内瓦": "西欧",
+            # 东欧（按你的知识库分类）
+            "华沙": "东欧", "克拉科夫": "东欧",
+            "莫斯科": "东欧", "圣彼得堡": "东欧",
+            # 南欧
+            "罗马": "南欧", "米兰": "南欧", "威尼斯": "南欧",
+            "马德里": "南欧", "巴塞罗那": "南欧",
+            "里斯本": "南欧", "波尔图": "南欧",
+            "雅典": "南欧", "圣托里尼": "南欧",
+            # 北欧
+            "斯德哥尔摩": "北欧", "哥德堡": "北欧",
+            "奥斯陆": "北欧", "卑尔根": "北欧",
+            "哥本哈根": "北欧", "赫尔辛基": "北欧",
+            "雷克雅未克": "北欧",
+        }
+        return city_region_mapping.get(city_name, "")
+    def get_knowledge_by_destination(self, destination: str) -> dict:
+        """根据目的地获取结构化的知识信息"""
+        relevant_items = self.search(destination)
+        if not relevant_items:
+            log.warning(f"⚠️ 未找到关于 '{destination}' 的知识")
+            return {}
+        # 合并所有相关知识
+        merged_knowledge = {
+            "destination_info": {},
+            "budget_analysis": {},
+            "detailed_itinerary": [],
+            "professional_insights": {}
+        }
+        for item in relevant_items:
+            knowledge = item.get('knowledge', {}).get('travel_knowledge', {})
+            # 合并目的地信息
+            if 'destination_info' in knowledge:
+                dest_info = knowledge['destination_info']
+                merged_knowledge['destination_info'].update(dest_info)
+            # 使用最详细的预算分析
+            if 'budget_analysis' in knowledge:
+                if not merged_knowledge['budget_analysis'] or len(knowledge['budget_analysis']) > len(merged_knowledge['budget_analysis']):
+                    merged_knowledge['budget_analysis'] = knowledge['budget_analysis']
+            # 合并行程建议
+            if 'detailed_itinerary' in knowledge:
+                merged_knowledge['detailed_itinerary'].extend(knowledge['detailed_itinerary'])
+            # 合并专业洞察
+            if 'professional_insights' in knowledge:
+                for key, value in knowledge['professional_insights'].items():
+                    if key not in merged_knowledge['professional_insights']:
+                        merged_knowledge['professional_insights'][key] = value
+                    elif isinstance(value, list):
+                        # 合并列表，去重
+                        existing = merged_knowledge['professional_insights'][key]
+                        if isinstance(existing, list):
+                            merged_knowledge['professional_insights'][key] = list(set(existing + value))
+        # 去重行程建议
+        if merged_knowledge['detailed_itinerary']:
+            seen_days = set()
+            unique_itinerary = []
+            for day_plan in merged_knowledge['detailed_itinerary']:
+                day_key = (day_plan.get('day_number', 0), day_plan.get('location', ''))
+                if day_key not in seen_days:
+                    seen_days.add(day_key)
+                    unique_itinerary.append(day_plan)
+            merged_knowledge['detailed_itinerary'] = unique_itinerary
+        log.info(f"📚 为 '{destination}' 合并了 {len(relevant_items)} 条知识记录")
+        return merged_knowledge
+    def get_similar_destinations(self, destination: str, limit: int = 5) -> list:
+        """获取相似的目的地推荐"""
+        similar_destinations = []
+        # 找到目标城市的国家和地区
+        target_country = self._find_country_for_city(destination)
+        target_region = self._find_region_for_city(destination)
+        # 优先推荐同国家的其他城市
+        if target_country and target_country in self.country_index:
+            for idx in self.country_index[target_country]:
+                knowledge = self.knowledge[idx].get('knowledge', {}).get('travel_knowledge', {})
+                dest_info = knowledge.get('destination_info', {})
+                destinations = dest_info.get('primary_destinations', [])
+                for dest in destinations:
+                    if dest != destination and dest not in similar_destinations:
+                        similar_destinations.append(dest)
+                        if len(similar_destinations) >= limit:
+                            return similar_destinations
+        # 然后推荐同地区的城市
+        if target_region and target_region in self.region_index and len(similar_destinations) < limit:
+            for idx in self.region_index[target_region]:
+                knowledge = self.knowledge[idx].get('knowledge', {}).get('travel_knowledge', {})
+                dest_info = knowledge.get('destination_info', {})
+                destinations = dest_info.get('primary_destinations', [])
+                for dest in destinations:
+                    if dest != destination and dest not in similar_destinations:
+                        similar_destinations.append(dest)
+                        if len(similar_destinations) >= limit:
+                            return similar_destinations
+        return similar_destinations
+    def get_statistics(self) -> dict:
+        """获取知识库统计信息"""
+        stats = {
+            "total_records": len(self.knowledge),
+            "cities_covered": len(self.city_index),
+            "countries_covered": len(self.country_index),
+            "regions_covered": len(self.region_index),
+            "cities_by_region": {},
+            "popular_cities": []
+        }
+        # 按地区统计城市数量
+        for region, indices in self.region_index.items():
+            cities_in_region = set()
+            for idx in indices:
+                knowledge = self.knowledge[idx].get('knowledge', {}).get('travel_knowledge', {})
+                dest_info = knowledge.get('destination_info', {})
+                cities_in_region.update(dest_info.get('primary_destinations', []))
+            stats["cities_by_region"][region] = len(cities_in_region)
+        # 找出出现频率最高的城市
+        city_frequency = {}
+        for city, indices in self.city_index.items():
+            city_frequency[city] = len(indices)
+        # 按出现频率排序
+        sorted_cities = sorted(city_frequency.items(), key=lambda x: x[1], reverse=True)
+        stats["popular_cities"] = sorted_cities[:10]  # 前10个最热门城市
+        return stats

modules/response_generator.py CHANGED Viewed

@@ -1,4 +1,5 @@
 import json
 from .ai_model import AIModel
 from .knowledge_base import KnowledgeBase
 from utils.logger import log
@@ -8,6 +9,7 @@ class ResponseGenerator:
         self.ai_model = ai_model
         self.kb = knowledge_base
         self.personas = self._load_personas()
     def _load_personas(self):
         personas_path = "./config/personas.json"
@@ -17,29 +19,76 @@ class ResponseGenerator:
             log.info(f"✅ 成功加载 {len(data.get('personas', {}))} 个persona配置。")
             return data.get('personas', {})
     def _get_current_persona_config(self, session_state: dict) -> dict:
-        persona_key = session_state.get("persona", {}).get("key") if isinstance(session_state.get("persona"), dict) else None
         return self.personas.get(persona_key, {
-            "name": "旅行助手", "style": "中立",
-            "tone": ["专业", "友好"], "prompt_template": self._build_generic_prompt(session_state)
         })
     def generate(self, user_message: str, session_state: dict, extracted_info: dict) -> str:
         try:
             response_parts = []
-            acknowledgement = self._generate_acknowledgement(extracted_info, session_state)
             if acknowledgement:
                 response_parts.append(acknowledgement)
-            next_question = self._get_next_question(session_state)
             if next_question:
                 if response_parts:
-                    response_parts.append("那么，" + next_question[0].lower() + next_question[1:])
                 else:
                     response_parts.append(next_question)
             if not next_question:
-                plan = self._generate_persona_enhanced_plan(user_message, session_state)
                 if response_parts:
                     response_parts.append("\n\n" + plan)
                 else:
@@ -51,128 +100,442 @@ class ResponseGenerator:
             log.error(f"❌ 响应生成失败: {e}", exc_info=True)
             return "抱歉，我在处理您的请求时遇到了问题，请稍后再试。"
-    def _get_next_question(self, session_state: dict) -> str:
-        """根据Persona风格，健壮地获取下一个问题，绝不崩溃。"""
-        persona_config = self._get_current_persona_config(session_state)
-        persona_style = persona_config.get("style", "中立")
-        # --- 核心修复：借鉴session_manager的健壮性检查逻辑 ---
-        destination_info = session_state.get("destination") # 可能为 None
-        duration_info = session_state.get("duration")       # 可能为 None
-        budget_info = session_state.get("budget")         # 可能为 None
-        # 只有当info是字典时才尝试获取深层数据，否则使用安全默认值
-        destination_name = destination_info.get('name', '那里') if isinstance(destination_info, dict) else '那里'
-        days = duration_info.get('days', '几') if isinstance(duration_info, dict) else '几'
-        # 依次检查核心信息是否缺失
-        if not destination_info:
-            if "社交" in persona_style: return "哈喽！准备好去哪里嗨皮了吗？告诉我想去哪个城市，我们来一场刷爆朋友圈的旅行吧！✨"
-            if "体验" in persona_style: return "你好，旅行者。为了开启一段独特的深度体验，你心中的目的地是哪里？"
-            return "您好！为了高效地开始规划，请首先明确您的目的地城市。"
-        if not duration_info:
-            if "社交" in persona_style: return f"{destination_name}超棒的！打算和小伙伴们在那玩几天呀？"
-            if "体验" in persona_style: return f"感知到了，{destination_name}。你希望在这片土地上沉浸多少个日夜？"
-            return f"目的地已锁定：{destination_name}。请提供计划的旅行天数。"
-        if not budget_info:
-            if "社交" in persona_style: return f"太棒啦，{days}天的行程！这次出去玩，预算大概是多少呀？是经济实惠，还是想来个轻奢体验呢？"
-            if "体验" in persona_style: return f"{days}天的探索之旅，听起来很不错。对于这次旅行的开销，你有什么样的构想？"
-            return f"已记录：行程共{days}天。请明确您的预算范围（例如：经济型、舒适型，或具体金额）。"
-        return "" # 所有信息已收集完毕
-    def _generate_acknowledgement(self, extracted_info: dict, session_state: dict) -> str:
-        # ... (此部分及以下方法与上一版健壮版本相同，无需修改) ...
-        if not extracted_info: return ""
-        persona_config = self._get_current_persona_config(session_state)
-        persona_style = persona_config.get("style", "")
-        ack_parts = []
-        if "destination" in extracted_info:
-            name = extracted_info['destination'].get('name', '目的地')
-            if "社交" in persona_style: ack_parts.append(f"目的地锁定{name}！已经开始期待啦！💖")
-            elif "体验" in persona_style: ack_parts.append(f"我感知到了，{name}，一个充满故事的地方")
-            else: ack_parts.append(f"确认：目的地已记录为{name}")
-        if "duration" in extracted_info:
-            days = extracted_info['duration'].get('days', '几')
-            if "社交" in persona_style: ack_parts.append(f"玩{days}天，时间超充裕的")
-            elif "体验" in persona_style: ack_parts.append(f"{days}个日夜，足够深入探索了")
-            else: ack_parts.append(f"行程时长已设定为{days}天")
-        if "budget" in extracted_info:
-            budget_desc = self._format_budget_info(extracted_info.get('budget'))
-            if "社交" in persona_style: ack_parts.append(f"{budget_desc}的预算，妥妥的")
-            elif "体验" in persona_style: ack_parts.append(f"了解，{budget_desc}的投入，追求的是价值而非价格")
-            else: ack_parts.append(f"预算已明确为{budget_desc}")
-        return "，".join(ack_parts) + "。" if ack_parts else ""
-    def _format_budget_info(self, budget: dict) -> str:
-        if not budget or not isinstance(budget, dict): return "未指定"
-        if budget.get('amount') and budget.get('currency'): return f"{budget['amount']}{budget['currency']}"
-        if budget.get('description'): return budget['description']
-        if budget.get('type'):
-            type_map = {'economy': '经济型', 'comfortable': '舒适型', 'luxury': '豪华型'}
-            return type_map.get(budget['type'], budget['type'])
-        return "未指定"
-    # --- 以下方法保持不变 ---
-    def _generate_persona_enhanced_plan(self, user_message: str, session_state: dict) -> str:
-        persona_config = self._get_current_persona_config(session_state)
-        if self.ai_model.is_available():
-            prompt = self._build_prompt(session_state, persona_config)
-            log.info(f"🚀 使用Persona '{persona_config.get('name')}' 构建的Prompt进行生成。")
-            return self.ai_model.generate(user_message, prompt)
         else:
-            log.warning("⚠️ AI模型不可用，生成备用计划。")
-            return self._generate_fallback_plan(session_state)
-    def _build_prompt(self, session_state: dict, persona_config: dict) -> str:
-        template = persona_config.get('prompt_template')
-        if not template:
-            return self._build_generic_prompt(session_state)
         try:
-            format_args = {
-                "location": self._safe_get_session_value(session_state, "destination", "name", "未指定"),
-                "days": self._safe_get_session_value(session_state, "duration", "days", "未指定"),
-                "budget": self._format_budget_info(session_state.get("budget")),
-                "date": session_state.get('date', '近期'),
-                "user_tags": ", ".join(session_state.get('user_tags', [])),
-                "commercial_preference": session_state.get('commercial_preference', '适中'),
-                "group_description": session_state.get('group_description', '个人'),
-                "tags": ", ".join(session_state.get('tags', []))
-            }
-            return template.format(**format_args)
-        except KeyError as e:
-            log.warning(f"Persona模板格式化失败，缺少键: {e}。将使用通用模板。")
-            return self._build_generic_prompt(session_state)
-    def _safe_get_session_value(self, session, key1, key2, default):
-        """安全地从嵌套的session字典中取值"""
-        level1 = session.get(key1)
-        if isinstance(level1, dict):
-            return level1.get(key2, default)
-        return default
-    def _build_generic_prompt(self, session_state: dict) -> str:
-        location = self._safe_get_session_value(session_state, "destination", "name", "目的地")
-        days = self._safe_get_session_value(session_state, "duration", "days", "几")
-        budget_info = self._format_budget_info(session_state.get("budget"))
-        return f"你是一个专业的旅游助手。请为用户生成一个详细的旅行计划。\n【基本信息】\n- 目的地：{location}\n- 旅行天数：{days}天\n- 预算：{budget_info}\n【要求】\n- 提供具体的景点推荐和路线安排\n- 包含交通、住宿、餐饮建议\n- 确保所有推荐都在预算范围内\n- 提供实用的旅行贴士\n\n请生成一份实用、详细的旅行计划。"
-    def _generate_fallback_plan(self, session_state: dict) -> str:
         persona_config = self._get_current_persona_config(session_state)
-        location = self._safe_get_session_value(session_state, "destination", "name", "目的地")
-        days = self._safe_get_session_value(session_state, "duration", "days", "几")
-        budget_info = self._format_budget_info(session_state.get("budget"))
-        persona_name = persona_config.get('name', '旅行者')
-        plan = f"为您推荐 {location} {days}天旅行计划：\n\n"
-        plan += f"👤 旅行者类型：{persona_name}\n"
-        plan += f"💰 预算范围：{budget_info}\n\n"
-        highlights = self._safe_get_session_value(session_state, "destination", "highlights", "精彩景点等待您的探索")
-        plan += f"🎯 主要景点：{highlights}\n\n"
-        persona_key = self._safe_get_session_value(session_state, "persona", "key", None)
-        if persona_key == 'planner': plan += "📋 建议制定详细的每日行程表。\n"
-        elif persona_key == 'social': plan += "📸 推荐寻找热门打卡点！\n"
-        elif persona_key == 'experiential': plan += "🎨 建议深入当地社区，寻找地道体验。\n"
-        plan += "\n如需更详细的个性化规划，请告诉我您的具体需求！"
-        return plan

 import json
+import random
 from .ai_model import AIModel
 from .knowledge_base import KnowledgeBase
 from utils.logger import log
         self.ai_model = ai_model
         self.kb = knowledge_base
         self.personas = self._load_personas()
+        self._init_response_templates()
     def _load_personas(self):
         personas_path = "./config/personas.json"
             log.info(f"✅ 成功加载 {len(data.get('personas', {}))} 个persona配置。")
             return data.get('personas', {})
+    def _init_response_templates(self):
+        """初始化各种动态回复模板"""
+        # 欧洲城市特色描述 (保留原有)
+        self.city_descriptions = {
+            "巴黎": ["浪漫之都", "艺术之城", "时尚之都", "光影流转的塞纳河畔", "充满香槟气息的花都"],
+            "罗马": ["永恒之城", "历史的活化石", "每块石头都有故事", "古典与现代交融的奇迹", "凯撒大帝走过的土地"],
+            "伦敦": ["绅士的故乡", "雾都传奇", "文艺复兴的摇篮", "泰晤士河的守护者", "莎士比亚笔下的世界"],
+            "维也纳": ["音乐之都", "华尔兹的发源地", "莫扎特的灵感之地", "咖啡文化的天堂", "皇室优雅的化身"],
+            "布拉格": ["千塔之城", "中世纪的童话", "波西米亚的浪漫", "查理桥上的传奇", "啤酒花香弥漫的古城"],
+            "布达佩斯": ["多瑙河明珠", "东欧巴黎", "温泉之都", "建筑艺术的博物馆", "匈牙利王冠上的明珠"],
+            "萨尔茨堡": ["音乐神童的故乡", "《音乐之声》的拍摄地", "阿尔卑斯山下的明珠", "莫扎特的诞生地", "巴洛克建筑的典范"],
+            "哈尔施塔特": ["世界最美小镇", "湖光山色的仙境", "阿尔卑斯山的秘境", "明信片上的童话", "奥地利的瑰宝"],
+        }
+        # 保留原有的问候语和确认模板 (简化以节省空间)
+        self.greetings = {
+            "social": [
+                "哈喽！准备开启一场说走就走的欧洲之旅吗？✨",
+                "嗨呀！听说有人要去欧洲拍美照啦？📸",
+            ],
+            "experiential": [
+                "你好，旅行者。欧洲的古老土地正在召唤着你...",
+                "感知到了一颗渴望探索的心。欧洲有太多故事等你去发现。",
+            ],
+            "planner": [
+                "您好！让我来帮您规划一次完美的欧洲之旅。",
+                "欧洲旅行规划专家上线！准备为您定制专属行程。",
+            ]
+        }
     def _get_current_persona_config(self, session_state: dict) -> dict:
+        """获取当前persona配置"""
+        persona_info = session_state.get("persona", {})
+        if isinstance(persona_info, dict):
+            persona_key = persona_info.get("key")
+        else:
+            persona_key = None
         return self.personas.get(persona_key, {
+            "name": "旅行助手",
+            "style": "中立",
+            "tone": ["专业", "友好"],
+            "prompt_template": self._build_generic_prompt(session_state)
         })
     def generate(self, user_message: str, session_state: dict, extracted_info: dict) -> str:
+        """生成融合知识库的智能回复"""
         try:
             response_parts = []
+            # 1. 生成确认信息（更生动）
+            acknowledgement = self._generate_vivid_acknowledgement(extracted_info, session_state)
             if acknowledgement:
                 response_parts.append(acknowledgement)
+            # 2. 检查是否需要询问下一个信息
+            next_question = self._get_dynamic_next_question(session_state)
             if next_question:
                 if response_parts:
+                    connectors = ["那么，", "接下来，", "好的，", ""]
+                    connector = random.choice(connectors)
+                    response_parts.append(connector + next_question)
                 else:
                     response_parts.append(next_question)
+            # 3. 如果所有信息收集完毕，生成知识库增强的旅行计划
             if not next_question:
+                plan = self._generate_knowledge_enhanced_plan(user_message, session_state)
                 if response_parts:
                     response_parts.append("\n\n" + plan)
                 else:
             log.error(f"❌ 响应生成失败: {e}", exc_info=True)
             return "抱歉，我在处理您的请求时遇到了问题，请稍后再试。"
+    def _generate_knowledge_enhanced_plan(self, user_message: str, session_state: dict) -> str:
+        """生成融合知识库信息的旅行计划"""
+        # 1. 获取目的地信息
+        destination_name = self._get_destination_name(session_state)
+        days = int(self._get_duration_days(session_state))
+        budget_info = self._format_budget_info(session_state.get("budget"))
+        log.info(f"🔍 开始搜索知识库中关于 '{destination_name}' 的信息...")
+        # 2. 搜索知识库中的相关信息
+        relevant_knowledge = self._search_destination_knowledge(destination_name)
+        # 3. 如果有AI模型，生成增强版计划
+        if self.ai_model and self.ai_model.is_available():
+            return self._generate_ai_enhanced_plan(session_state, relevant_knowledge)
+        else:
+            # 4. 否则生成基于知识库的详细备用计划
+            return self._generate_knowledge_based_fallback_plan(session_state, relevant_knowledge)
+    def _search_destination_knowledge(self, destination_name: str) -> dict:
+        """搜索知识库中与目的地相关的信息"""
+        if not self.kb or not hasattr(self.kb, 'knowledge') or not self.kb.knowledge:
+            log.warning("⚠️ 知识库为空或不可用")
+            return {}
+        relevant_info = {
+            "budget_analysis": {},
+            "itinerary_suggestions": [],
+            "professional_insights": {},
+            "destination_specific": {}
+        }
+        log.info(f"📚 在 {len(self.kb.knowledge)} 条知识中搜索关于 '{destination_name}' 的信息...")
+        # 遍历知识库
+        for item in self.kb.knowledge:
+            knowledge = item.get('knowledge', {}).get('travel_knowledge', {})
+            if not knowledge:
+                continue
+            # 检查是否与目标目的地相关
+            dest_info = knowledge.get('destination_info', {})
+            primary_destinations = dest_info.get('primary_destinations', [])
+            countries = dest_info.get('countries', [])
+            # 判断相关性
+            is_relevant = False
+            match_reason = ""
+            # 直接匹配城市名
+            if destination_name in primary_destinations:
+                is_relevant = True
+                match_reason = f"直接匹配城市: {destination_name}"
+            # 通过国家匹配
+            if not is_relevant:
+                dest_country = self._get_destination_country(destination_name)
+                if dest_country and dest_country in countries:
+                    is_relevant = True
+                    match_reason = f"通过国家匹配: {dest_country}"
+            # 地区匹配 (如果目的地在同一地区)
+            if not is_relevant:
+                region_destinations = self._get_same_region_cities(destination_name)
+                if any(city in primary_destinations for city in region_destinations):
+                    is_relevant = True
+                    match_reason = f"同地区匹配: {region_destinations}"
+            if is_relevant:
+                log.info(f"✅ 找到相关知识: {match_reason}")
+                # 提取预算分析
+                if 'budget_analysis' in knowledge:
+                    relevant_info['budget_analysis'] = knowledge['budget_analysis']
+                # 提取行程建议
+                if 'detailed_itinerary' in knowledge:
+                    relevant_info['itinerary_suggestions'].extend(knowledge['detailed_itinerary'])
+                # 提取专业洞察
+                if 'professional_insights' in knowledge:
+                    relevant_info['professional_insights'].update(knowledge['professional_insights'])
+                # 提取目的地特定信息
+                relevant_info['destination_specific'] = dest_info
+        if relevant_info['budget_analysis'] or relevant_info['itinerary_suggestions']:
+            log.info(f"📊 成功提取知识库信息: 预算分析={bool(relevant_info['budget_analysis'])}, 行程建议={len(relevant_info['itinerary_suggestions'])}条")
         else:
+            log.warning(f"⚠️ 未找到关于 '{destination_name}' 的相关知识")
+        return relevant_info
+    def _get_destination_country(self, city_name: str) -> str:
+        """获取城市所属国家"""
+        city_country_mapping = {
+            "布拉格": "捷克", "维也纳": "奥地利", "萨尔茨堡": "奥地利",
+            "布达佩斯": "匈牙利", "布拉迪斯拉发": "斯洛伐克",
+            "哈尔施塔特": "奥地利", "巴德伊舍": "奥地利",
+            "库特纳霍拉": "捷克", "布尔诺": "捷克",
+            "巴黎": "法国", "里昂": "法国", "尼斯": "法国",
+            "柏林": "德国", "慕尼黑": "德国", "汉堡": "德国",
+            "阿姆斯特丹": "荷兰", "鹿特丹": "荷兰",
+            "布鲁塞尔": "比利时", "安特卫普": "比利时",
+            "苏黎世": "瑞士", "日内瓦": "瑞士",
+        }
+        return city_country_mapping.get(city_name, "")
+    def _get_same_region_cities(self, city_name: str) -> list:
+        """获取同地区的其他城市"""
+        region_mapping = {
+            # 中欧城市
+            "布拉格": ["维也纳", "萨尔茨堡", "布达佩斯", "布拉迪斯拉发", "哈尔施塔特"],
+            "维也纳": ["布拉格", "萨尔茨堡", "布达佩斯", "布拉迪斯拉发", "哈尔施塔特"],
+            "萨尔茨堡": ["维也纳", "布拉格", "哈尔施塔特", "慕尼黑"],
+            "布达佩斯": ["布拉格", "维也纳", "布拉迪斯拉发"],
+            "哈尔施塔特": ["萨尔茨堡", "维也纳", "巴德伊舍"],
+            # 西欧城市
+            "巴黎": ["布鲁塞尔", "阿姆斯特丹", "科隆", "斯特拉斯堡"],
+            "阿姆斯特丹": ["布鲁塞尔", "科隆", "巴黎"],
+            "布鲁塞尔": ["阿姆斯特丹", "巴黎", "科隆"],
+            # 德语区
+            "柏林": ["慕尼黑", "科隆", "汉堡", "维也纳", "苏黎世"],
+            "慕尼黑": ["柏林", "萨尔茨堡", "苏黎世", "维也纳"],
+            "苏黎世": ["慕尼黑", "维也纳", "萨尔茨堡"],
+        }
+        return region_mapping.get(city_name, [])
+    def _generate_ai_enhanced_plan(self, session_state: dict, knowledge: dict) -> str:
+        """使用AI模型生成融合知识库的计划"""
+        # 构建包含知识库信息的enhanced prompt
+        enhanced_prompt = self._build_knowledge_enhanced_prompt(session_state, knowledge)
         try:
+            log.info("🤖 使用AI模型生成知识库增强计划...")
+            response = self.ai_model.run_inference(
+                input_type="text",
+                formatted_input=None,
+                prompt=enhanced_prompt,
+                temperature=0.7
+            )
+            return response
+        except Exception as e:
+            log.error(f"❌ AI增强计划生成失败: {e}")
+            return self._generate_knowledge_based_fallback_plan(session_state, knowledge)
+    def _build_knowledge_enhanced_prompt(self, session_state: dict, knowledge: dict) -> str:
+        """构建融合知识库信息的增强prompt"""
+        destination_name = self._get_destination_name(session_state)
+        days = self._get_duration_days(session_state)
+        budget_desc = self._format_budget_info(session_state.get("budget"))
         persona_config = self._get_current_persona_config(session_state)
+        # 基础prompt
+        prompt = f"""你是一位专业的欧洲旅行顾问，请基于以下知识库信息为用户设计{destination_name}的详细旅行计划。
+🎯 【用户需求】
+📍 目的地: {destination_name}
+⏰ 旅行天数: {days}天
+💰 预算: {budget_desc}
+🎭 旅行风格: {persona_config.get('name', '标准旅行者')}
+📚 【知识库参考信息】"""
+        # 添加预算分析信息
+        if knowledge.get('budget_analysis'):
+            budget_analysis = knowledge['budget_analysis']
+            prompt += f"""
+💰 【预算参考】
+• 总预算范围: {budget_analysis.get('total_budget_range', 'N/A')}
+• 日均开支: {budget_analysis.get('daily_average', 'N/A')}"""
+            breakdown = budget_analysis.get('budget_breakdown', {})
+            if breakdown:
+                prompt += "\n• 预算分配:"
+                for category, info in breakdown.items():
+                    if isinstance(info, dict):
+                        percentage = info.get('percentage', '')
+                        daily_range = info.get('daily_range', '')
+                        if percentage and daily_range:
+                            category_name = {'accommodation': '住宿', 'transportation': '交通',
+                                           'food': '餐饮', 'attractions': '景点'}.get(category, category)
+                            prompt += f"\n  - {category_name}: {percentage}, {daily_range}"
+        # 添加行程参考信息
+        if knowledge.get('itinerary_suggestions'):
+            prompt += f"""
+🗓️ 【行程参考】"""
+            for day_plan in knowledge['itinerary_suggestions'][:3]:  # 只取前3天作为参考
+                day_num = day_plan.get('day_number', 'N/A')
+                location = day_plan.get('location', 'N/A')
+                theme = day_plan.get('theme', 'N/A')
+                prompt += f"\n• Day {day_num} ({location}): {theme}"
+                # 添加具体活动
+                morning_activities = day_plan.get('morning_activities', [])
+                for activity in morning_activities[:2]:  # 只取前2个活动
+                    name = activity.get('activity_name', '')
+                    duration = activity.get('duration', '')
+                    tips = activity.get('professional_tips', '')
+                    if name:
+                        prompt += f"\n  - {name} ({duration}) - {tips}"
+        # 添加专业洞察
+        if knowledge.get('professional_insights'):
+            insights = knowledge['professional_insights']
+            prompt += f"""
+💡 【专业建议】"""
+            if insights.get('seasonal_considerations'):
+                seasonal = insights['seasonal_considerations']
+                best_months = seasonal.get('best_months', [])
+                if best_months:
+                    prompt += f"\n• 最佳旅行时间: {', '.join(best_months)}"
+            if insights.get('common_mistakes'):
+                mistakes = insights['common_mistakes'][:3]  # 只取前3个
+                prompt += f"\n• 常见误区: {', '.join(mistakes)}"
+            if insights.get('insider_secrets'):
+                secrets = insights['insider_secrets'][:3]  # 只取前3个
+                prompt += f"\n• 内行贴士: {', '.join(secrets)}"
+        # 结尾指令
+        prompt += f"""
+🌟 【生成要求】
+请基于以上知识库信息，结合用户的具体需求，生成一份详细、实用、个性化的{destination_name}{days}天旅行计划。计划应该包括:
+• 每日详细行程安排
+• 具体的景点推荐和游览建议
+• 住宿和餐饮推荐
+• 交通方式和路线优化
+• 预算分解和省钱贴士
+• 实用的旅行提醒
+请用生动有趣的语言撰写，让用户感受到{destination_name}的魅力！"""
+        return prompt
+    def _generate_knowledge_based_fallback_plan(self, session_state: dict, knowledge: dict) -> str:
+        """基于知识库生成详细的备用计划"""
+        destination_name = self._get_destination_name(session_state)
+        days = int(self._get_duration_days(session_state))
+        budget_desc = self._format_budget_info(session_state.get("budget"))
+        persona_config = self._get_current_persona_config(session_state)
+        persona_key = persona_config.get('key', 'planner')
+        # 获取城市特色描述
+        city_desc = random.choice(self.city_descriptions.get(destination_name, ["迷人的城市"]))
+        # 开场
+        if persona_key == 'social':
+            plan = f"🎉 {destination_name}{days}天深度攻略（知识库加持版）！\n\n"
+        elif persona_key == 'experiential':
+            plan = f"🎭 {destination_name}{days}日文化探索之旅\n\n"
+        else:
+            plan = f"📋 {destination_name}{days}天专业规划方案\n\n"
+        plan += f"🌟 城市印象：{city_desc}\n"
+        plan += f"💰 预算范围：{budget_desc}\n\n"
+        # 如果有知识库中的预算分析
+        if knowledge.get('budget_analysis'):
+            budget_analysis = knowledge['budget_analysis']
+            plan += "💰 【预算详解】（基于真实旅行经验）\n"
+            total_budget = budget_analysis.get('total_budget_range', '')
+            daily_avg = budget_analysis.get('daily_average', '')
+            if total_budget:
+                plan += f"• 参考总预算：{total_budget}\n"
+            if daily_avg:
+                plan += f"• 日均开支：{daily_avg}\n"
+            breakdown = budget_analysis.get('budget_breakdown', {})
+            if breakdown:
+                plan += "• 开支分配：\n"
+                category_names = {
+                    'accommodation': '🏨 住宿', 'transportation': '🚇 交通',
+                    'food': '🍽️ 餐饮', 'attractions': '🎯 景点'
+                }
+                for category, info in breakdown.items():
+                    if isinstance(info, dict):
+                        name = category_names.get(category, category)
+                        percentage = info.get('percentage', '')
+                        daily_range = info.get('daily_range', '')
+                        if percentage and daily_range:
+                            plan += f"  - {name}：{percentage}，{daily_range}\n"
+                        # 添加具体建议
+                        if category == 'accommodation' and info.get('recommendations'):
+                            recs = ', '.join(info['recommendations'])
+                            plan += f"    推荐：{recs}\n"
+                        elif category == 'transportation' and info.get('money_saving_tips'):
+                            tips = ', '.join(info['money_saving_tips'])
+                            plan += f"    省钱技巧：{tips}\n"
+            plan += "\n"
+        # 详细行程规划（基于知识库）
+        plan += "🗓️ 【详细行程】（来自实地经验）\n"
+        if knowledge.get('itinerary_suggestions'):
+            # 使用知识库中的行程建议
+            itinerary = knowledge['itinerary_suggestions']
+            for i, day_plan in enumerate(itinerary[:days]):  # 限制在用户要求的天数内
+                day_num = day_plan.get('day_number', i+1)
+                location = day_plan.get('location', destination_name)
+                theme = day_plan.get('theme', '城市探索')
+                plan += f"\n📅 Day {day_num} - {location}（{theme}）\n"
+                # 上午活动
+                morning_activities = day_plan.get('morning_activities', [])
+                if morning_activities:
+                    plan += "🌅 上午：\n"
+                    for activity in morning_activities:
+                        name = activity.get('activity_name', '')
+                        duration = activity.get('duration', '')
+                        cost = activity.get('cost', '')
+                        tips = activity.get('professional_tips', '')
+                        plan += f"  • {name}"
+                        if duration:
+                            plan += f" ({duration})"
+                        if cost and cost != "免费":
+                            plan += f" - {cost}"
+                        plan += "\n"
+                        if tips:
+                            plan += f"    💡 专业提醒：{tips}\n"
+                # 下午活动
+                afternoon_activities = day_plan.get('afternoon_activities', [])
+                if afternoon_activities:
+                    plan += "🌞 下午：\n"
+                    for activity in afternoon_activities:
+                        name = activity.get('activity_name', '')
+                        duration = activity.get('duration', '')
+                        cost = activity.get('cost', '')
+                        plan += f"  • {name}"
+                        if duration:
+                            plan += f" ({duration})"
+                        if cost:
+                            plan += f" - {cost}"
+                        plan += "\n"
+                # 餐饮建议
+                dining = day_plan.get('dining', {})
+                if dining:
+                    plan += "🍽️ 餐饮推荐：\n"
+                    for meal_type, meal_info in dining.items():
+                        if isinstance(meal_info, dict):
+                            meal_names = {'breakfast': '早餐', 'lunch': '午餐', 'dinner': '晚餐'}
+                            meal_name = meal_names.get(meal_type, meal_type)
+                            recommendation = meal_info.get('recommendation', '')
+                            cost_range = meal_info.get('cost_range', '')
+                            if recommendation:
+                                plan += f"  • {meal_name}：{recommendation}"
+                                if cost_range:
+                                    plan += f" ({cost_range})"
+                                plan += "\n"
+                # 住宿建议
+                accommodation = day_plan.get('accommodation', {})
+                if accommodation and day_num == 1:  # 只在第一天显示住宿建议
+                    plan += "🏨 住宿推荐：\n"
+                    area = accommodation.get('recommended_area', '')
+                    safety = accommodation.get('safety_level', '')
+                    if area:
+                        plan += f"  • 推荐区域：{area}"
+                        if safety:
+                            plan += f"（安全等级：{safety}）"
+                        plan += "\n"
+                    budget_options = accommodation.get('budget_options', [])
+                    for option in budget_options:
+                        if isinstance(option, dict):
+                            category = option.get('category', '')
+                            price_range = option.get('price_range', '')
+                            if category and price_range:
+                                plan += f"  • {category}：{price_range}\n"
+        else:
+            # 如果没有具体行程，生成通用建议
+            plan += f"根据{destination_name}的特色，为您推荐以下{days}天行程框架：\n\n"
+            # 根据不同城市提供基础框架
+            if destination_name in ["布拉格", "Prague"]:
+                plan += "📅 Day 1: 老城区探索（老城广场→天文钟→查理大桥）\n"
+                plan += "📅 Day 2: 城堡区深度游（布拉格城堡→圣维特大教堂→黄金小巷）\n"
+                if days >= 3:
+                    plan += "📅 Day 3: 新城区体验（瓦茨拉夫广场→国家博物馆→当地美食）\n"
+            elif destination_name in ["维也纳", "Vienna"]:
+                plan += "📅 Day 1: 皇室风采（美泉宫→霍夫堡宫→圣斯蒂芬大教堂）\n"
+                plan += "📅 Day 2: 音乐文化（维也纳国家歌剧院→金色大厅→艺术史博物馆）\n"
+                if days >= 3:
+                    plan += "📅 Day 3: 咖啡文化体验（中央咖啡馆→萨赫咖啡馆→多瑙河漫步）\n"
+            elif destination_name in ["布达佩斯", "Budapest"]:
+                plan += "📅 Day 1: 布达一侧（布达城堡→渔夫堡→马加什教堂）\n"
+                plan += "📅 Day 2: 佩斯一侧（匈牙利国会大厦→链子桥→中央市场）\n"
+                if days >= 3:
+                    plan += "📅 Day 3: 温泉文化（塞切尼温泉→多瑙河游船→夜景欣赏）\n"
+        # 添加专业洞察
+        if knowledge.get('professional_insights'):
+            insights = knowledge['professional_insights']
+            plan += "\n💡 【专业贴士】（来自旅行达人）\n"
+            # 季节建议
+            seasonal = insights.get('seasonal_considerations', {})
+            if seasonal:
+                best_months = seasonal.get('best_months', [])
+                weather = seasonal.get('weather_patterns', '')
+                if best_months:
+                    plan += f"• 🌤️ 最佳旅行时间：{', '.join(best_months)}\n"
+                if weather:
+                    plan += f"• 🌡️ 天气特点：{weather}\n"
+            #