2848 lines
118 KiB
Python
2848 lines
118 KiB
Python
"""LLM-to-Cypher graph QA engine for enterprise knowledge-base questions."""
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import copy
|
||
import json
|
||
import re
|
||
import time
|
||
from typing import Any
|
||
|
||
from falkordb import FalkorDB
|
||
|
||
from app.config import settings
|
||
from app.db import get_agent_settings
|
||
from app.llm_client import LlmClient
|
||
|
||
GRAPH_QA_MAX_LIMIT = 300
|
||
SCHEMA_CACHE_TTL_SECONDS = 300
|
||
QA_RESPONSE_CACHE_TTL_SECONDS = 600
|
||
CYPHER_CACHE_TTL_SECONDS = 1800
|
||
GRAPH_QA_PLANNER_TIMEOUT_SECONDS = 2.5
|
||
GRAPH_QA_CYPHER_TIMEOUT_SECONDS = 4.5
|
||
GRAPH_QA_REPAIR_TIMEOUT_SECONDS = 5.0
|
||
GRAPH_QA_ANSWER_TIMEOUT_SECONDS = 6.0
|
||
_SCHEMA_CACHE: dict[str, tuple[float, dict[str, Any]]] = {}
|
||
_QA_RESPONSE_CACHE: dict[str, tuple[float, dict[str, Any]]] = {}
|
||
_CYPHER_CACHE: dict[str, tuple[float, dict[str, Any]]] = {}
|
||
WRITE_KEYWORDS = re.compile(
|
||
r"\b(CREATE|MERGE|SET|DELETE|DETACH|DROP|REMOVE|CALL\s+DB\.IDX|CALL\s+DB\.CONSTRAINT)\b",
|
||
re.IGNORECASE,
|
||
)
|
||
READ_START = re.compile(r"^(MATCH|RETURN|CALL)\b", re.IGNORECASE)
|
||
|
||
GRAPH_QA_PLANNER_SYS = """你是百姓惠知识图谱客服问答的路由规划器。只输出 JSON：
|
||
{"intent":"...","route":"...","confidence":0.0,"reason":"...","need_llm_graph":false}
|
||
任务：判断用户问题应该先走哪条链路，不生成答案、不生成 Cypher。
|
||
可选 intent：
|
||
route_catalog、price_quote、fee_detail、vehicle_catalog、route_multihop_detail、
|
||
condition_route_advice、route_compare_suitability、route_compare_scenic_count、
|
||
route_context_advice、general_graph_qa。
|
||
可选 route：
|
||
template_graph_query、deterministic_context_llm_answer、llm_graph_qa。
|
||
原则：高频客服问题优先 template_graph_query；需要推荐/解释但图谱可固定取证时选 deterministic_context_llm_answer；
|
||
无法用模板覆盖的长尾问题才选 llm_graph_qa。不要臆造线路名。"""
|
||
|
||
GRAPH_QA_CYPHER_SYS = """你是 FalkorDB/RedisGraph 只读 Cypher 规划器。只输出 JSON：
|
||
{"cypher":"...","reason":"...","answer_focus":"..."}
|
||
规则：只允许 MATCH/RETURN/CALL；禁止 CREATE/MERGE/SET/DELETE/DETACH/DROP/REMOVE；必须 LIMIT；中文用 CONTAINS。
|
||
只给一条最短可执行查询，cypher 控制在 800 字以内，不要输出示例、解释或多条备选。
|
||
百姓惠常用标签：TourProduct、ProductDay、RouteStop、ScenicAttraction、TravelItem、ProductPricePlan、PolicyRule、SalesScript。
|
||
价格：TourProduct-[:PRODUCT_HAS_PRICE_PLAN]->ProductPricePlan，字段 adult_price_min/max、child_price_min/max、single_room_diff_min/max。
|
||
费用/小交通：TourProduct-[:PRODUCT_USES_TRAVEL_ITEM]->TravelItem；TravelItem 字段 name、type、subtype、category、price、adult_price、unit、raw_evidence、requires_supplier_confirm。
|
||
黄小西/小西：按黄果树、小七孔、西江相关线路匹配。"""
|
||
|
||
GRAPH_QA_REPAIR_SYS = """你是 FalkorDB/RedisGraph Cypher 修复器。只输出 JSON。
|
||
根据执行错误修复上一条只读 Cypher。仍然必须只读、以 MATCH/RETURN/CALL 开头、带 LIMIT。
|
||
字段：cypher、reason、answer_focus。"""
|
||
|
||
GRAPH_QA_ANSWER_SYS = """你是百姓惠客服图谱问答助手。只输出 JSON。
|
||
基于 graph_result 回答，不编造价格、余位、房型、车辆或承诺；证据不足就提示二次核实。
|
||
customer_reply 控制在 100 字内，answer 控制在 360 字内。
|
||
字段：answer、customer_reply、confidence、follow_up_questions、risk_notes、evidence_cards。"""
|
||
|
||
|
||
def _get_graph(graph_name: str):
|
||
db = FalkorDB(host=settings.falkordb_host, port=settings.falkordb_port)
|
||
return db.select_graph(graph_name)
|
||
|
||
|
||
def _safe_int(value: Any, default: int) -> int:
|
||
try:
|
||
return int(value)
|
||
except Exception:
|
||
return default
|
||
|
||
|
||
async def _chat_json_with_retry(
|
||
client: LlmClient,
|
||
system_prompt: str,
|
||
user_prompt: str,
|
||
*,
|
||
attempts: int = 2,
|
||
) -> dict[str, Any]:
|
||
last_exc: Exception | None = None
|
||
for attempt in range(max(1, attempts)):
|
||
try:
|
||
return await asyncio.to_thread(client.chat_json, system_prompt, user_prompt)
|
||
except Exception as exc: # noqa: BLE001
|
||
last_exc = exc
|
||
if attempt >= attempts - 1:
|
||
break
|
||
await asyncio.sleep(0.8 * (attempt + 1))
|
||
raise last_exc or RuntimeError("LLM JSON 调用失败")
|
||
|
||
|
||
async def _chat_json_timed(
|
||
client: LlmClient,
|
||
system_prompt: str,
|
||
user_prompt: str,
|
||
*,
|
||
timeout_seconds: float,
|
||
attempts: int = 1,
|
||
) -> dict[str, Any]:
|
||
return await asyncio.wait_for(
|
||
_chat_json_with_retry(client, system_prompt, user_prompt, attempts=attempts),
|
||
timeout=timeout_seconds,
|
||
)
|
||
|
||
|
||
async def _graph_qa_client(max_tokens: int = 1600, *, use_config_max_tokens: bool = True) -> LlmClient | None:
|
||
try:
|
||
cfg = await get_agent_settings()
|
||
except Exception:
|
||
cfg = {}
|
||
|
||
api_access = cfg.get("api_access") if isinstance(cfg, dict) else {}
|
||
qa_llm = (api_access or {}).get("qa_llm") if isinstance(api_access, dict) else {}
|
||
if isinstance(qa_llm, dict) and qa_llm.get("base_url") and qa_llm.get("api_key"):
|
||
configured_max_tokens = _safe_int(qa_llm.get("max_tokens"), max_tokens)
|
||
return LlmClient(
|
||
qa_llm["base_url"],
|
||
qa_llm["api_key"],
|
||
qa_llm.get("model") or settings.llm_model or "deepseek-chat",
|
||
timeout=_safe_int(qa_llm.get("timeout"), settings.llm_timeout_seconds or 45),
|
||
max_tokens=min(configured_max_tokens, max_tokens) if use_config_max_tokens else max_tokens,
|
||
)
|
||
|
||
global_cfg = cfg.get("global") if isinstance(cfg, dict) else {}
|
||
if isinstance(global_cfg, dict) and global_cfg.get("base_url") and global_cfg.get("api_key"):
|
||
return LlmClient(
|
||
global_cfg["base_url"],
|
||
global_cfg["api_key"],
|
||
global_cfg.get("model") or settings.llm_model or "deepseek-chat",
|
||
timeout=_safe_int(global_cfg.get("timeout"), settings.llm_timeout_seconds or 45),
|
||
max_tokens=max_tokens,
|
||
)
|
||
|
||
if settings.llm_api_base and settings.llm_api_key:
|
||
return LlmClient(
|
||
settings.llm_api_base,
|
||
settings.llm_api_key,
|
||
settings.llm_model or "deepseek-chat",
|
||
timeout=settings.llm_timeout_seconds,
|
||
max_tokens=max_tokens,
|
||
)
|
||
|
||
extract = cfg.get("extract") if isinstance(cfg, dict) else {}
|
||
extract = extract if isinstance(extract, dict) else {}
|
||
models = extract.get("models") or {}
|
||
models = models if isinstance(models, dict) else {}
|
||
keys = [extract.get("aggregator")] + [
|
||
key for key, value in models.items() if isinstance(value, dict) and value.get("enabled")
|
||
] + list(models.keys())
|
||
for key in keys:
|
||
model_cfg = models.get(key or "")
|
||
if isinstance(model_cfg, dict) and model_cfg.get("base_url") and model_cfg.get("api_key"):
|
||
return LlmClient(
|
||
model_cfg["base_url"],
|
||
model_cfg["api_key"],
|
||
model_cfg.get("model") or settings.llm_model or "deepseek-chat",
|
||
timeout=int(extract.get("timeout") or settings.llm_timeout_seconds or 60),
|
||
max_tokens=max_tokens,
|
||
)
|
||
return None
|
||
|
||
|
||
def _assert_read_only(cypher: str) -> None:
|
||
if not cypher:
|
||
raise ValueError("Cypher query required")
|
||
if WRITE_KEYWORDS.search(cypher):
|
||
raise ValueError("Read-only queries only")
|
||
if not READ_START.match(cypher):
|
||
raise ValueError("Only MATCH, RETURN, or CALL queries allowed")
|
||
|
||
|
||
def _clean_cypher(cypher: Any, limit: int) -> str:
|
||
text = str(cypher or "").strip()
|
||
text = re.sub(r"^```(?:cypher)?\s*", "", text, flags=re.I).strip()
|
||
text = text.removesuffix("```").strip().rstrip(";")
|
||
if not re.search(r"\bLIMIT\s+\d+\b", text, flags=re.IGNORECASE):
|
||
text = f"{text} LIMIT {limit}"
|
||
_assert_read_only(text)
|
||
return text
|
||
|
||
|
||
def _compact_scalar(value: Any, limit: int = 500) -> Any:
|
||
if value is None or isinstance(value, (int, float, bool)):
|
||
return value
|
||
if isinstance(value, (list, tuple)):
|
||
return [_compact_scalar(item, 180) for item in value[:20]]
|
||
text = re.sub(r"\s+", " ", str(value)).strip()
|
||
return text[:limit]
|
||
|
||
|
||
def _node_id(node: Any) -> str:
|
||
value = getattr(node, "id", None)
|
||
return str(value if value is not None else node)
|
||
|
||
|
||
def _node_summary(node: Any) -> dict[str, Any]:
|
||
props = dict(getattr(node, "properties", None) or {})
|
||
labels = list(getattr(node, "labels", None) or [])
|
||
title = ""
|
||
for key in (
|
||
"display_name", "name", "title", "label", "product_name",
|
||
"route_line_name", "natural_key", "product_id", "item_id",
|
||
):
|
||
if props.get(key):
|
||
title = str(props[key])
|
||
break
|
||
if not title:
|
||
title = f"{labels[0] if labels else 'Node'} #{_node_id(node)}"
|
||
return {
|
||
"id": _node_id(node),
|
||
"labels": labels,
|
||
"title": title[:160],
|
||
"properties": {str(k): _compact_scalar(v, 700) for k, v in props.items()},
|
||
}
|
||
|
||
|
||
def _edge_summary(edge: Any) -> dict[str, Any]:
|
||
props = dict(getattr(edge, "properties", None) or {})
|
||
return {
|
||
"id": str(getattr(edge, "id", "")),
|
||
"type": str(getattr(edge, "relation", "") or ""),
|
||
"from": _node_id(getattr(edge, "src_node", "")),
|
||
"to": _node_id(getattr(edge, "dest_node", "")),
|
||
"properties": {str(k): _compact_scalar(v, 300) for k, v in props.items()},
|
||
}
|
||
|
||
|
||
def _compact_value(value: Any) -> Any:
|
||
if hasattr(value, "labels") and hasattr(value, "properties"):
|
||
return {"node": _node_summary(value)}
|
||
if hasattr(value, "src_node") and hasattr(value, "dest_node"):
|
||
return {"relationship": _edge_summary(value)}
|
||
if (
|
||
hasattr(value, "nodes")
|
||
and callable(getattr(value, "nodes"))
|
||
and hasattr(value, "edges")
|
||
and callable(getattr(value, "edges"))
|
||
):
|
||
return {
|
||
"path": {
|
||
"nodes": [_node_summary(node) for node in value.nodes()],
|
||
"relationships": [_edge_summary(edge) for edge in value.edges()],
|
||
}
|
||
}
|
||
if isinstance(value, (list, tuple)):
|
||
return [_compact_value(item) for item in value[:20]]
|
||
if isinstance(value, dict):
|
||
return {str(k): _compact_value(v) for k, v in list(value.items())[:30]}
|
||
return _compact_scalar(value)
|
||
|
||
|
||
def _extract_graph_items(rows: list[list[Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
|
||
nodes: dict[str, dict[str, Any]] = {}
|
||
edges: dict[str, dict[str, Any]] = {}
|
||
|
||
def walk(value: Any) -> None:
|
||
if hasattr(value, "labels") and hasattr(value, "properties"):
|
||
nodes.setdefault(_node_id(value), _node_summary(value))
|
||
return
|
||
if hasattr(value, "src_node") and hasattr(value, "dest_node"):
|
||
edge = _edge_summary(value)
|
||
key = edge["id"] or f"{edge['from']}-{edge['type']}-{edge['to']}"
|
||
edges.setdefault(key, edge)
|
||
return
|
||
if (
|
||
hasattr(value, "nodes")
|
||
and callable(getattr(value, "nodes"))
|
||
and hasattr(value, "edges")
|
||
and callable(getattr(value, "edges"))
|
||
):
|
||
for node in value.nodes():
|
||
walk(node)
|
||
for edge in value.edges():
|
||
walk(edge)
|
||
return
|
||
if isinstance(value, (list, tuple)):
|
||
for item in value:
|
||
walk(item)
|
||
|
||
for row in rows:
|
||
walk(row)
|
||
return list(nodes.values()), list(edges.values())
|
||
|
||
|
||
def _header_names(header: Any) -> list[str]:
|
||
out: list[str] = []
|
||
for item in header or []:
|
||
if isinstance(item, (list, tuple)) and len(item) > 1:
|
||
out.append(str(item[1]))
|
||
else:
|
||
out.append(str(item))
|
||
return out
|
||
|
||
|
||
def _run_cypher(graph_name: str, cypher: str, limit: int) -> dict[str, Any]:
|
||
graph = _get_graph(graph_name)
|
||
result = graph.query(cypher)
|
||
rows = list(result.result_set)[:limit]
|
||
nodes, relationships = _extract_graph_items(rows)
|
||
compact_rows = [[_compact_value(value) for value in row] for row in rows[:40]]
|
||
return {
|
||
"cypher": cypher,
|
||
"columns": _header_names(result.header),
|
||
"rows": compact_rows,
|
||
"row_count": len(rows),
|
||
"nodes": nodes,
|
||
"relationships": relationships,
|
||
}
|
||
|
||
|
||
FEE_QUESTION_TERMS = (
|
||
"费用", "自费", "自理", "另付", "不含", "包含", "小交通", "观光车", "环保车",
|
||
"电瓶车", "索道", "扶梯", "游船", "门票", "二消", "必付", "可选",
|
||
)
|
||
PRICE_QUESTION_TERMS = (
|
||
"多少钱", "价格", "报价", "成人价", "儿童价", "小孩价", "房差", "单房差", "结算价",
|
||
)
|
||
VEHICLE_QUESTION_TERMS = (
|
||
"车型", "车辆", "用车", "车有哪些", "什么车", "商务车", "大巴", "中巴", "小包团用车",
|
||
)
|
||
COMPLEX_QUESTION_TERMS = (
|
||
"推荐", "对比", "比较", "为什么", "怎么安排", "如何安排", "适合", "帮我", "方案",
|
||
"预算", "老人", "亲子", "团队", "定制", "如果", "同时", "综合", "详细行程",
|
||
)
|
||
FAMILY_CONDITION_TERMS = ("老人", "老年", "长辈", "小孩", "孩子", "儿童", "亲子", "家庭", "一家")
|
||
COMFORT_CONDITION_TERMS = ("不累", "不要太累", "太累", "轻松", "舒适", "少走路", "慢一点", "不赶", "休闲", "轻奢")
|
||
BUDGET_CONDITION_TERMS = ("预算", "便宜", "划算", "性价比", "不贵", "低价", "经济")
|
||
ROUTE_COMPARE_TERMS = ("哪个", "哪条", "对比", "比较", "更多", "更少", "包含")
|
||
SCENIC_QUESTION_TERMS = (
|
||
"景区", "景点", "去哪", "去哪里", "去哪些", "游玩", "打卡", "途经", "经过",
|
||
)
|
||
HOTEL_QUESTION_TERMS = (
|
||
"酒店", "住宿", "入住", "住哪里", "住哪", "附近酒店", "附近入住", "附近住宿",
|
||
)
|
||
SCENIC_HINT_ALIASES: dict[str, tuple[str, ...]] = {
|
||
"荔波小七孔景区": ("小七孔", "荔波"),
|
||
"西江千户苗寨景区": ("西江", "千户苗寨", "苗寨"),
|
||
"黄果树旅游景区": ("黄果树", "瀑布"),
|
||
"梵净山景区": ("梵净山", "镇梵"),
|
||
"青岩古镇": ("青岩", "青岩古镇"),
|
||
"镇远古城": ("镇远", "镇远古城"),
|
||
"贵阳": ("贵阳",),
|
||
"安顺": ("安顺",),
|
||
}
|
||
FEE_EVIDENCE_TERMS = (
|
||
"raw_evidence", "ScenicTransport", "ScenicOptional", "景区费用项目", "观光车",
|
||
"环保车", "电瓶车", "小交通", "索道", "扶梯", "游船", "门票", "自费", "不含", "另付",
|
||
)
|
||
|
||
|
||
def _is_fee_question(question: str) -> bool:
|
||
return any(term in question for term in FEE_QUESTION_TERMS)
|
||
|
||
|
||
def _is_price_question(question: str) -> bool:
|
||
return any(term in question for term in PRICE_QUESTION_TERMS)
|
||
|
||
|
||
def _is_vehicle_question(question: str) -> bool:
|
||
return any(term in question for term in VEHICLE_QUESTION_TERMS)
|
||
|
||
|
||
def _has_duration_question(question: str) -> bool:
|
||
return bool(_route_duration_clauses(question)) or any(term in question for term in ("几天", "多少天", "天数", "玩几天", "行程几天"))
|
||
|
||
|
||
def _is_scenic_question(question: str) -> bool:
|
||
return any(term in question for term in SCENIC_QUESTION_TERMS)
|
||
|
||
|
||
def _is_hotel_question(question: str) -> bool:
|
||
return any(term in question for term in HOTEL_QUESTION_TERMS)
|
||
|
||
|
||
def _is_route_multihop_question(question: str) -> bool:
|
||
if not _route_name_terms(question) or not _is_hotel_question(question):
|
||
return False
|
||
facets = [
|
||
_is_price_question(question),
|
||
_has_duration_question(question),
|
||
_is_scenic_question(question),
|
||
_is_hotel_question(question),
|
||
]
|
||
return sum(1 for item in facets if item) >= 3
|
||
|
||
|
||
def _is_route_compare_scenic_count_question(question: str) -> bool:
|
||
terms = _route_name_terms(question)
|
||
return (
|
||
len(terms) >= 2
|
||
and any(term in question for term in ROUTE_COMPARE_TERMS)
|
||
and any(term in question for term in ("景点", "景区", "包含", "去的地方", "玩的地方"))
|
||
and any(term in question for term in ("更多", "多", "少", "哪个", "哪条"))
|
||
)
|
||
|
||
|
||
def _is_route_compare_suitability_question(question: str) -> bool:
|
||
terms = _route_name_terms(question)
|
||
slots = _condition_slots(question)
|
||
return (
|
||
len(terms) >= 2
|
||
and (slots["family"] or slots["comfort"] or slots["budget"])
|
||
and any(term in question for term in ("哪个", "哪条", "对比", "比较", "适合", "推荐", "为什么"))
|
||
)
|
||
|
||
|
||
def _condition_slots(question: str) -> dict[str, bool]:
|
||
return {
|
||
"family": any(term in question for term in FAMILY_CONDITION_TERMS),
|
||
"comfort": any(term in question for term in COMFORT_CONDITION_TERMS),
|
||
"budget": any(term in question for term in BUDGET_CONDITION_TERMS),
|
||
"recommend": any(term in question for term in ("推荐", "适合", "有没有", "哪条", "帮我", "怎么选")),
|
||
}
|
||
|
||
|
||
def _is_condition_route_advice_question(question: str) -> bool:
|
||
slots = _condition_slots(question)
|
||
return (
|
||
not _route_name_terms(question)
|
||
and slots["recommend"]
|
||
and (slots["family"] or slots["comfort"] or slots["budget"])
|
||
)
|
||
|
||
|
||
def _normalized_question(question: str) -> str:
|
||
text = re.sub(r"\s+", "", question.strip().lower())
|
||
return (
|
||
text.replace("路线", "线路")
|
||
.replace("产品", "线路")
|
||
.replace("报价", "价格")
|
||
.replace("成人价", "价格")
|
||
.replace("小孩价", "儿童价")
|
||
)
|
||
|
||
|
||
PLANNER_ROUTE_BY_INTENT = {
|
||
"route_catalog": "template_graph_query",
|
||
"price_quote": "template_graph_query",
|
||
"fee_detail": "template_graph_query",
|
||
"vehicle_catalog": "template_graph_query",
|
||
"route_multihop_detail": "template_graph_query",
|
||
"condition_route_advice": "template_graph_query",
|
||
"route_compare_suitability": "template_graph_query",
|
||
"route_compare_scenic_count": "template_graph_query",
|
||
"route_context_advice": "deterministic_context_llm_answer",
|
||
"general_graph_qa": "llm_graph_qa",
|
||
}
|
||
|
||
|
||
def _planner_enabled_from_context(customer_context: dict[str, Any] | None) -> bool:
|
||
if not isinstance(customer_context, dict):
|
||
return False
|
||
value = customer_context.get("llm_planner")
|
||
if value is None:
|
||
value = customer_context.get("force_llm_planner")
|
||
return str(value).strip().lower() in {"1", "true", "yes", "on", "启用", "强制"}
|
||
|
||
|
||
def _should_use_llm_planner(intent: dict[str, Any], customer_context: dict[str, Any] | None) -> bool:
|
||
if _planner_enabled_from_context(customer_context):
|
||
return True
|
||
route = str(intent.get("route") or "")
|
||
confidence = _safe_confidence(intent.get("confidence"), 0.0)
|
||
return route == "llm_graph_qa" or confidence < 0.7
|
||
|
||
|
||
def _planner_trace(
|
||
*,
|
||
used: bool,
|
||
skipped_reason: str = "",
|
||
latency_ms: int = 0,
|
||
error: str = "",
|
||
decision: dict[str, Any] | None = None,
|
||
) -> dict[str, Any]:
|
||
return {
|
||
"used": used,
|
||
"latency_ms": latency_ms,
|
||
"timeout_ms": round(GRAPH_QA_PLANNER_TIMEOUT_SECONDS * 1000),
|
||
"skipped_reason": skipped_reason,
|
||
"error": error,
|
||
"decision": decision or {},
|
||
}
|
||
|
||
|
||
def _normalize_planner_decision(base_intent: dict[str, Any], decision: dict[str, Any]) -> dict[str, Any]:
|
||
planned_intent = str(decision.get("intent") or "").strip()
|
||
if planned_intent not in PLANNER_ROUTE_BY_INTENT:
|
||
return base_intent
|
||
confidence = _safe_confidence(decision.get("confidence"), _safe_confidence(base_intent.get("confidence"), 0.55))
|
||
route = PLANNER_ROUTE_BY_INTENT[planned_intent]
|
||
return {
|
||
**base_intent,
|
||
"intent": planned_intent,
|
||
"route": route,
|
||
"confidence": confidence,
|
||
"complexity": str(decision.get("complexity") or base_intent.get("complexity") or "planned"),
|
||
"reason": str(decision.get("reason") or base_intent.get("reason") or "LLM 规划器选择链路。")[:260],
|
||
"planner_need_llm_graph": bool(decision.get("need_llm_graph")) or route == "llm_graph_qa",
|
||
}
|
||
|
||
|
||
async def _llm_plan_intent(
|
||
question: str,
|
||
graph_name: str,
|
||
base_intent: dict[str, Any],
|
||
customer_context: dict[str, Any] | None,
|
||
) -> tuple[dict[str, Any], dict[str, Any]]:
|
||
if not _should_use_llm_planner(base_intent, customer_context):
|
||
return base_intent, _planner_trace(used=False, skipped_reason="high_confidence_template_or_context_route")
|
||
client = await _graph_qa_client(max_tokens=320, use_config_max_tokens=False)
|
||
if client is None:
|
||
return base_intent, _planner_trace(used=False, skipped_reason="llm_not_configured")
|
||
client.timeout = min(float(getattr(client, "timeout", GRAPH_QA_PLANNER_TIMEOUT_SECONDS) or GRAPH_QA_PLANNER_TIMEOUT_SECONDS), GRAPH_QA_PLANNER_TIMEOUT_SECONDS)
|
||
payload = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"rule_intent": base_intent,
|
||
"route_terms": _route_name_terms(question),
|
||
"condition_slots": _condition_slots(question),
|
||
"allowed_intents": list(PLANNER_ROUTE_BY_INTENT.keys()),
|
||
"customer_context": customer_context or {},
|
||
}
|
||
started = time.perf_counter()
|
||
try:
|
||
decision = await _chat_json_timed(
|
||
client,
|
||
GRAPH_QA_PLANNER_SYS,
|
||
json.dumps(payload, ensure_ascii=False),
|
||
timeout_seconds=GRAPH_QA_PLANNER_TIMEOUT_SECONDS,
|
||
attempts=1,
|
||
)
|
||
except asyncio.TimeoutError:
|
||
latency_ms = max(1, round((time.perf_counter() - started) * 1000))
|
||
return base_intent, _planner_trace(used=True, latency_ms=latency_ms, error="planner_timeout")
|
||
except Exception as exc: # noqa: BLE001
|
||
latency_ms = max(1, round((time.perf_counter() - started) * 1000))
|
||
return base_intent, _planner_trace(used=True, latency_ms=latency_ms, error=str(exc)[:220])
|
||
latency_ms = max(1, round((time.perf_counter() - started) * 1000))
|
||
planned = _normalize_planner_decision(base_intent, decision)
|
||
return planned, _planner_trace(used=True, latency_ms=latency_ms, decision=decision)
|
||
|
||
|
||
def _classify_graph_qa_intent(question: str) -> dict[str, Any]:
|
||
normalized = _normalized_question(question)
|
||
terms = _route_name_terms(question)
|
||
duration_clauses = _route_duration_clauses(question)
|
||
complex_hint = len(question) > 72 or any(term in question for term in COMPLEX_QUESTION_TERMS)
|
||
intent = {
|
||
"intent": "general_graph_qa",
|
||
"route": "llm_graph_qa",
|
||
"confidence": 0.48 if complex_hint else 0.58,
|
||
"complexity": "complex" if complex_hint else "open",
|
||
"slots": {
|
||
"route_terms": terms,
|
||
"has_duration": bool(duration_clauses),
|
||
},
|
||
"reason": "未命中标准模板，使用 LLM 生成 Cypher 做通用图查询。",
|
||
}
|
||
if _is_route_list_question(question):
|
||
return {
|
||
**intent,
|
||
"intent": "route_catalog",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.95,
|
||
"complexity": "standard",
|
||
"reason": "线路清单类问题可由 TourProduct 固定模板回答。",
|
||
}
|
||
if _is_condition_route_advice_question(question):
|
||
return {
|
||
**intent,
|
||
"intent": "condition_route_advice",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.82,
|
||
"complexity": "standard_condition_filter",
|
||
"slots": {
|
||
**intent["slots"],
|
||
"condition_slots": _condition_slots(question),
|
||
},
|
||
"reason": "未指定线路但给出家庭/舒适/预算条件，使用固定图查询筛选候选线路并模板回答。",
|
||
}
|
||
if _is_route_compare_suitability_question(question):
|
||
return {
|
||
**intent,
|
||
"intent": "route_compare_suitability",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.84,
|
||
"complexity": "standard_suitability_compare",
|
||
"slots": {
|
||
**intent["slots"],
|
||
"condition_slots": _condition_slots(question),
|
||
},
|
||
"reason": "多线路适配度对比已识别条件词，可固定取证后用评分模板快速回答。",
|
||
}
|
||
if _is_route_compare_scenic_count_question(question):
|
||
return {
|
||
**intent,
|
||
"intent": "route_compare_scenic_count",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.86,
|
||
"complexity": "standard_compare",
|
||
"reason": "线路景点数量对比可由固定取证统计 ScenicAttraction 数量回答。",
|
||
}
|
||
if _is_vehicle_question(question) and any(term in normalized for term in ("车型", "车辆", "用车", "车")):
|
||
return {
|
||
**intent,
|
||
"intent": "vehicle_catalog",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.88,
|
||
"complexity": "standard",
|
||
"reason": "车辆/车型类问题可由 TravelItem 用车项目固定模板回答。",
|
||
}
|
||
if _is_route_multihop_question(question):
|
||
return {
|
||
**intent,
|
||
"intent": "route_multihop_detail",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.91,
|
||
"complexity": "standard_multihop",
|
||
"reason": "线路价格、天数、途经景区和附近酒店属于标准多跳图谱查询，可用固定模板快速回答。",
|
||
}
|
||
if _is_price_question(question) and terms:
|
||
return {
|
||
**intent,
|
||
"intent": "price_quote",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.9,
|
||
"complexity": "standard",
|
||
"reason": "线路报价类问题已识别线路实体和天数，可直接查 ProductPricePlan。",
|
||
}
|
||
if _is_fee_question(question) and terms:
|
||
return {
|
||
**intent,
|
||
"intent": "fee_detail",
|
||
"route": "template_graph_query",
|
||
"confidence": 0.86,
|
||
"complexity": "standard",
|
||
"reason": "费用/小交通类问题已识别线路实体，可直接查 TravelItem。",
|
||
}
|
||
if complex_hint and terms:
|
||
return {
|
||
**intent,
|
||
"intent": "route_context_advice",
|
||
"route": "deterministic_context_llm_answer",
|
||
"confidence": 0.76,
|
||
"complexity": "complex_with_entities",
|
||
"reason": "复杂推荐/对比问题已识别线路实体，先用固定 Cypher 取证据，再让 LLM 基于证据组织答案。",
|
||
}
|
||
return intent
|
||
|
||
|
||
def _has_fee_evidence(graph_result: dict[str, Any]) -> bool:
|
||
if not graph_result.get("row_count"):
|
||
return False
|
||
text = json.dumps(
|
||
{
|
||
"rows": graph_result.get("rows") or [],
|
||
"nodes": graph_result.get("nodes") or [],
|
||
"relationships": graph_result.get("relationships") or [],
|
||
},
|
||
ensure_ascii=False,
|
||
default=str,
|
||
)
|
||
return any(term in text for term in FEE_EVIDENCE_TERMS)
|
||
|
||
|
||
def _cypher_quote(value: str) -> str:
|
||
return value.replace("\\", "\\\\").replace("'", "\\'")
|
||
|
||
|
||
def _is_valid_route_term(term: str) -> bool:
|
||
text = term.strip()
|
||
if len(text) < 2:
|
||
return False
|
||
noisy_fragments = (
|
||
"适合", "推荐", "有没有", "不要", "不累", "太累", "轻松", "舒适", "老人", "小孩",
|
||
"孩子", "儿童", "家庭", "预算", "便宜", "划算", "哪些", "什么", "哪个", "多少",
|
||
"可以", "附近", "入住", "酒店",
|
||
)
|
||
if any(fragment in text for fragment in noisy_fragments):
|
||
return False
|
||
return True
|
||
|
||
|
||
def _route_name_terms(question: str) -> list[str]:
|
||
terms: list[str] = []
|
||
if "小西镇梵" in question:
|
||
terms.append("小西镇梵")
|
||
if "黄小西镇梵" in question:
|
||
terms.append("黄小西镇梵")
|
||
if "黄小西" in question:
|
||
terms.append("黄小西")
|
||
elif "小西" in question:
|
||
terms.append("小西")
|
||
for term in ("黄果树", "小七孔", "荔波", "西江", "千户苗寨", "青岩", "梵净山", "镇远"):
|
||
if term in question:
|
||
terms.append(term)
|
||
if not terms:
|
||
for match in re.findall(r"[\u4e00-\u9fa5A-Za-z0-9]{2,12}(?:游|线路|产品|团)", question):
|
||
terms.append(match.replace("线路", "").replace("产品", "").replace("团", ""))
|
||
out: list[str] = []
|
||
for term in terms:
|
||
if _is_valid_route_term(term) and term not in out:
|
||
out.append(term)
|
||
return out[:6]
|
||
|
||
|
||
def _route_duration_clauses(question: str) -> list[str]:
|
||
match = re.search(r"(\d+)\s*(?:日|天)", question)
|
||
days = int(match.group(1)) if match else None
|
||
chinese_days = {"一": 1, "二": 2, "两": 2, "三": 3, "四": 4, "五": 5, "六": 6, "七": 7}
|
||
for text, value in chinese_days.items():
|
||
if f"{text}日" in question or f"{text}天" in question:
|
||
days = value
|
||
break
|
||
if not days:
|
||
return []
|
||
return [
|
||
f"p.duration_days = {days}",
|
||
f"p.name CONTAINS '{days}日'",
|
||
f"p.name CONTAINS '{days}天'",
|
||
f"p.name CONTAINS '{list(chinese_days.keys())[list(chinese_days.values()).index(days)]}日'" if days in chinese_days.values() else "",
|
||
]
|
||
|
||
|
||
def _fee_fallback_cypher(question: str, limit: int) -> str | None:
|
||
terms = _route_name_terms(question)
|
||
if not terms:
|
||
return None
|
||
name_clauses: list[str] = []
|
||
for term in terms:
|
||
quoted = _cypher_quote(term)
|
||
name_clauses.extend([
|
||
f"p.name CONTAINS '{quoted}'",
|
||
f"p.display_name CONTAINS '{quoted}'",
|
||
f"p.product_name CONTAINS '{quoted}'",
|
||
])
|
||
duration_clauses = [item for item in _route_duration_clauses(question) if item]
|
||
where_parts = [f"({' OR '.join(name_clauses)})"]
|
||
if duration_clauses:
|
||
where_parts.append(f"({' OR '.join(duration_clauses)})")
|
||
where_clause = " AND ".join(where_parts)
|
||
return f"""
|
||
MATCH (p:TourProduct)
|
||
WHERE {where_clause}
|
||
OPTIONAL MATCH (p)-[:PRODUCT_USES_TRAVEL_ITEM]->(direct_item:TravelItem)
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_DAY]->(d:ProductDay)-[:DAY_HAS_STOP]->(s:RouteStop)
|
||
OPTIONAL MATCH (s)-[:STOP_VISITS_ATTRACTION]->(a:ScenicAttraction)
|
||
OPTIONAL MATCH (s)-[:STOP_USES_TRAVEL_ITEM]->(stop_item:TravelItem)
|
||
OPTIONAL MATCH (a)-[:ATTRACTION_HAS_ITEM]->(attraction_item:TravelItem)
|
||
RETURN
|
||
p.name AS product_name,
|
||
p.product_id AS product_id,
|
||
p.duration_days AS duration_days,
|
||
collect(DISTINCT {{
|
||
name: direct_item.name,
|
||
type: direct_item.type,
|
||
subtype: direct_item.subtype,
|
||
category: direct_item.category,
|
||
status: direct_item.default_status,
|
||
price: direct_item.price,
|
||
adult_price: direct_item.adult_price,
|
||
unit: direct_item.unit,
|
||
raw_evidence: direct_item.raw_evidence,
|
||
requires_supplier_confirm: direct_item.requires_supplier_confirm
|
||
}}) AS product_items,
|
||
collect(DISTINCT {{
|
||
stop_name: s.name,
|
||
attraction_name: a.name,
|
||
name: stop_item.name,
|
||
type: stop_item.type,
|
||
subtype: stop_item.subtype,
|
||
category: stop_item.category,
|
||
status: stop_item.default_status,
|
||
price: stop_item.price,
|
||
adult_price: stop_item.adult_price,
|
||
unit: stop_item.unit,
|
||
raw_evidence: stop_item.raw_evidence,
|
||
requires_supplier_confirm: stop_item.requires_supplier_confirm
|
||
}}) AS stop_items,
|
||
collect(DISTINCT {{
|
||
stop_name: s.name,
|
||
attraction_name: a.name,
|
||
name: attraction_item.name,
|
||
type: attraction_item.type,
|
||
subtype: attraction_item.subtype,
|
||
category: attraction_item.category,
|
||
status: attraction_item.default_status,
|
||
price: attraction_item.price,
|
||
adult_price: attraction_item.adult_price,
|
||
unit: attraction_item.unit,
|
||
raw_evidence: attraction_item.raw_evidence,
|
||
requires_supplier_confirm: attraction_item.requires_supplier_confirm
|
||
}}) AS attraction_items
|
||
LIMIT {limit}
|
||
""".strip()
|
||
|
||
|
||
def _price_fallback_cypher(question: str, limit: int) -> str | None:
|
||
terms = _route_name_terms(question)
|
||
if not terms:
|
||
return None
|
||
name_clauses: list[str] = []
|
||
for term in terms:
|
||
quoted = _cypher_quote(term)
|
||
name_clauses.extend([
|
||
f"p.name CONTAINS '{quoted}'",
|
||
f"p.display_name CONTAINS '{quoted}'",
|
||
f"p.product_name CONTAINS '{quoted}'",
|
||
])
|
||
duration_clauses = [item for item in _route_duration_clauses(question) if item]
|
||
where_parts = [f"({' OR '.join(name_clauses)})"]
|
||
if duration_clauses:
|
||
where_parts.append(f"({' OR '.join(duration_clauses)})")
|
||
where_clause = " AND ".join(where_parts)
|
||
return f"""
|
||
MATCH (p:TourProduct)
|
||
WHERE {where_clause}
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_PRICE_PLAN]->(plan:ProductPricePlan)
|
||
RETURN
|
||
p.name AS product_name,
|
||
p.product_id AS product_id,
|
||
p.duration_days AS duration_days,
|
||
collect(DISTINCT {{
|
||
plan_name: plan.plan_name,
|
||
display_name: plan.display_name,
|
||
adult_price_min: plan.adult_price_min,
|
||
adult_price_max: plan.adult_price_max,
|
||
child_price_min: plan.child_price_min,
|
||
child_price_max: plan.child_price_max,
|
||
single_room_diff_min: plan.single_room_diff_min,
|
||
single_room_diff_max: plan.single_room_diff_max,
|
||
adult_settlement_source: plan.adult_settlement_source,
|
||
child_settlement_source: plan.child_settlement_source
|
||
}}) AS price_plans
|
||
LIMIT {limit}
|
||
""".strip()
|
||
|
||
|
||
def _route_catalog_cypher(limit: int) -> str:
|
||
return f"""
|
||
MATCH (p:TourProduct)
|
||
RETURN
|
||
p.name AS product_name,
|
||
p.display_name AS display_name,
|
||
p.product_id AS product_id,
|
||
p.duration_days AS duration_days
|
||
ORDER BY p.duration_days, p.name
|
||
LIMIT {limit}
|
||
""".strip()
|
||
|
||
|
||
def _vehicle_catalog_cypher(limit: int) -> str:
|
||
return f"""
|
||
MATCH (item:TravelItem)
|
||
WHERE item.name CONTAINS '车'
|
||
OR item.subtype CONTAINS '用车'
|
||
OR item.category CONTAINS '用车'
|
||
RETURN
|
||
item.name AS name,
|
||
item.type AS type,
|
||
item.subtype AS subtype,
|
||
item.price AS price,
|
||
item.unit AS unit,
|
||
item.raw_evidence AS raw_evidence
|
||
ORDER BY item.name
|
||
LIMIT {limit}
|
||
""".strip()
|
||
|
||
|
||
def _route_context_cypher(question: str, limit: int) -> str | None:
|
||
terms = _route_name_terms(question)
|
||
if not terms:
|
||
return None
|
||
name_clauses: list[str] = []
|
||
for term in terms:
|
||
quoted = _cypher_quote(term)
|
||
name_clauses.extend([
|
||
f"p.name CONTAINS '{quoted}'",
|
||
f"p.display_name CONTAINS '{quoted}'",
|
||
f"p.product_name CONTAINS '{quoted}'",
|
||
])
|
||
where_clause = f"({' OR '.join(name_clauses)})"
|
||
return f"""
|
||
MATCH (p:TourProduct)
|
||
WHERE {where_clause}
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_PRICE_PLAN]->(plan:ProductPricePlan)
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_DAY]->(d:ProductDay)-[:DAY_HAS_STOP]->(s:RouteStop)
|
||
OPTIONAL MATCH (s)-[:STOP_VISITS_ATTRACTION]->(a:ScenicAttraction)
|
||
RETURN
|
||
p.name AS product_name,
|
||
p.product_id AS product_id,
|
||
p.duration_days AS duration_days,
|
||
collect(DISTINCT {{
|
||
plan_name: plan.plan_name,
|
||
adult_price_min: plan.adult_price_min,
|
||
adult_price_max: plan.adult_price_max,
|
||
child_price_min: plan.child_price_min,
|
||
child_price_max: plan.child_price_max,
|
||
single_room_diff_min: plan.single_room_diff_min,
|
||
single_room_diff_max: plan.single_room_diff_max
|
||
}}) AS price_plans,
|
||
collect(DISTINCT {{
|
||
day: d.day_index,
|
||
stop_name: s.name,
|
||
attraction_name: a.name,
|
||
sequence: s.sequence
|
||
}}) AS route_points,
|
||
count(DISTINCT a) AS attraction_count
|
||
LIMIT {min(limit, 40)}
|
||
""".strip()
|
||
|
||
|
||
def _condition_context_cypher(limit: int) -> str:
|
||
return f"""
|
||
MATCH (p:TourProduct)
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_PRICE_PLAN]->(plan:ProductPricePlan)
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_DAY]->(d:ProductDay)-[:DAY_HAS_STOP]->(s:RouteStop)
|
||
OPTIONAL MATCH (s)-[:STOP_VISITS_ATTRACTION]->(a:ScenicAttraction)
|
||
RETURN
|
||
p.name AS product_name,
|
||
p.product_id AS product_id,
|
||
p.duration_days AS duration_days,
|
||
collect(DISTINCT {{
|
||
plan_name: plan.plan_name,
|
||
adult_price_min: plan.adult_price_min,
|
||
adult_price_max: plan.adult_price_max,
|
||
child_price_min: plan.child_price_min,
|
||
child_price_max: plan.child_price_max,
|
||
single_room_diff_min: plan.single_room_diff_min,
|
||
single_room_diff_max: plan.single_room_diff_max
|
||
}}) AS price_plans,
|
||
collect(DISTINCT {{
|
||
day: d.day_index,
|
||
stop_name: s.name,
|
||
attraction_name: a.name,
|
||
sequence: s.sequence
|
||
}}) AS route_points,
|
||
count(DISTINCT a) AS attraction_count
|
||
ORDER BY p.duration_days, p.name
|
||
LIMIT {min(limit, 80)}
|
||
""".strip()
|
||
|
||
|
||
def _scenic_hint_terms(question: str) -> list[str]:
|
||
hints: list[str] = []
|
||
for scenic_name, aliases in SCENIC_HINT_ALIASES.items():
|
||
if scenic_name in question or any(alias in question for alias in aliases):
|
||
hints.append(scenic_name)
|
||
hints.extend(aliases)
|
||
out: list[str] = []
|
||
for hint in hints:
|
||
if hint and hint not in out:
|
||
out.append(hint)
|
||
return out
|
||
|
||
|
||
def _route_feature_terms(question: str) -> list[str]:
|
||
candidates = ("轻奢", "纯玩", "2+1", "头等舱", "精品", "小团", "私家团", "跟团", "亲子")
|
||
return [term for term in candidates if term in question]
|
||
|
||
|
||
def _route_multihop_cypher(question: str, limit: int) -> str | None:
|
||
terms = _route_name_terms(question)
|
||
if not terms:
|
||
return None
|
||
name_clauses: list[str] = []
|
||
for term in terms + _route_feature_terms(question):
|
||
quoted = _cypher_quote(term)
|
||
name_clauses.extend([
|
||
f"p.name CONTAINS '{quoted}'",
|
||
f"p.display_name CONTAINS '{quoted}'",
|
||
f"p.product_name CONTAINS '{quoted}'",
|
||
])
|
||
duration_clauses = [item for item in _route_duration_clauses(question) if item]
|
||
where_parts = [f"({' OR '.join(name_clauses)})"]
|
||
if duration_clauses:
|
||
where_parts.append(f"({' OR '.join(duration_clauses)})")
|
||
where_clause = " AND ".join(where_parts)
|
||
return f"""
|
||
MATCH (p:TourProduct)
|
||
WHERE {where_clause}
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_PRICE_PLAN]->(plan:ProductPricePlan)
|
||
OPTIONAL MATCH (p)-[:PRODUCT_HAS_DAY]->(d:ProductDay)-[:DAY_HAS_STOP]->(s:RouteStop)
|
||
OPTIONAL MATCH (s)-[:STOP_VISITS_ATTRACTION]->(a:ScenicAttraction)
|
||
OPTIONAL MATCH (a)-[near:ATTRACTION_NEARBY_HOTEL]-(h:Hotel)
|
||
RETURN
|
||
p.name AS product_name,
|
||
p.product_id AS product_id,
|
||
p.duration_days AS duration_days,
|
||
collect(DISTINCT {{
|
||
plan_name: plan.plan_name,
|
||
display_name: plan.display_name,
|
||
adult_price_min: plan.adult_price_min,
|
||
adult_price_max: plan.adult_price_max,
|
||
child_price_min: plan.child_price_min,
|
||
child_price_max: plan.child_price_max,
|
||
single_room_diff_min: plan.single_room_diff_min,
|
||
single_room_diff_max: plan.single_room_diff_max
|
||
}}) AS price_plans,
|
||
collect(DISTINCT {{
|
||
day: d.day_index,
|
||
sequence: s.sequence,
|
||
stop_name: s.name,
|
||
attraction_name: a.name
|
||
}}) AS route_points,
|
||
collect(DISTINCT {{
|
||
scenic_name: a.name,
|
||
stop_name: s.name,
|
||
hotel_name: h.name,
|
||
star_rating: h.star_rating,
|
||
city: h.city,
|
||
county: h.county,
|
||
address: h.address,
|
||
features: h.features,
|
||
driving_distance_km: near.driving_distance_km,
|
||
driving_time_minutes: near.driving_time_minutes,
|
||
recommend_rank: near.recommend_rank,
|
||
usage_note: near.usage_note,
|
||
remark: near.remark
|
||
}}) AS nearby_hotels
|
||
LIMIT {min(limit, 60)}
|
||
""".strip()
|
||
|
||
|
||
def _schema_snapshot(graph_name: str) -> dict[str, Any]:
|
||
now = time.monotonic()
|
||
cached = _SCHEMA_CACHE.get(graph_name)
|
||
if cached and now - cached[0] <= SCHEMA_CACHE_TTL_SECONDS:
|
||
return cached[1]
|
||
graph = _get_graph(graph_name)
|
||
labels: list[dict[str, Any]] = []
|
||
relations: list[dict[str, Any]] = []
|
||
samples: list[dict[str, Any]] = []
|
||
try:
|
||
for labels_value, count in graph.query(
|
||
"MATCH (n) RETURN labels(n) AS labels, count(n) AS count LIMIT 120"
|
||
).result_set:
|
||
label = labels_value[0] if labels_value else ""
|
||
labels.append({"label": label, "count": count})
|
||
except Exception:
|
||
labels = []
|
||
try:
|
||
for rel_type, count in graph.query(
|
||
"MATCH ()-[r]->() RETURN type(r) AS type, count(r) AS count LIMIT 160"
|
||
).result_set:
|
||
relations.append({"type": rel_type, "count": count})
|
||
except Exception:
|
||
relations = []
|
||
for item in labels[:12]:
|
||
label = item.get("label")
|
||
if not label or not re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", str(label)):
|
||
continue
|
||
try:
|
||
rows = graph.query(f"MATCH (n:{label}) RETURN n LIMIT 1").result_set
|
||
except Exception:
|
||
continue
|
||
for row in rows:
|
||
node = row[0]
|
||
props = dict(getattr(node, "properties", None) or {})
|
||
samples.append({
|
||
"label": label,
|
||
"properties": {
|
||
str(k): _compact_scalar(v, 120)
|
||
for k, v in list(props.items())[:12]
|
||
},
|
||
})
|
||
snapshot = {"labels": labels[:80], "relations": relations[:100], "node_samples": samples[:16]}
|
||
_SCHEMA_CACHE[graph_name] = (now, snapshot)
|
||
return snapshot
|
||
|
||
|
||
def _list_texts(value: Any, limit: int, text_limit: int) -> list[str]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
out: list[str] = []
|
||
for item in value[:limit]:
|
||
text = re.sub(r"\s+", " ", str(item or "")).strip()
|
||
if text:
|
||
out.append(text[:text_limit])
|
||
return out
|
||
|
||
|
||
def _is_route_list_question(question: str) -> bool:
|
||
return any(term in question for term in ("线路有哪些", "路线有哪些", "产品有哪些", "有哪些线路", "有哪些路线", "有哪些产品", "旅行车线路"))
|
||
|
||
|
||
def _route_items_from_rows(graph_result: dict[str, Any]) -> list[dict[str, Any]]:
|
||
items: list[dict[str, Any]] = []
|
||
seen: set[str] = set()
|
||
for row in graph_result.get("rows") or []:
|
||
if not isinstance(row, list) or not row:
|
||
continue
|
||
name = ""
|
||
duration = None
|
||
for value in row:
|
||
if isinstance(value, str) and value.strip():
|
||
name = value.strip()
|
||
break
|
||
for value in row:
|
||
if isinstance(value, (int, float)) and 0 < value <= 30:
|
||
duration = int(value)
|
||
break
|
||
if name and name not in seen:
|
||
seen.add(name)
|
||
items.append({"name": name, "duration_days": duration})
|
||
return items
|
||
|
||
|
||
def _money(value: Any) -> str:
|
||
if value in (None, ""):
|
||
return ""
|
||
try:
|
||
number = float(value)
|
||
except Exception:
|
||
return str(value)
|
||
if number.is_integer():
|
||
return str(int(number))
|
||
return f"{number:.2f}".rstrip("0").rstrip(".")
|
||
|
||
|
||
def _money_range(min_value: Any, max_value: Any, unit: str = "元/人") -> str:
|
||
low = _money(min_value)
|
||
high = _money(max_value)
|
||
if low and high and low != high:
|
||
return f"{low}-{high}{unit}"
|
||
if low or high:
|
||
return f"{low or high}{unit}"
|
||
return ""
|
||
|
||
|
||
def _price_plans_from_rows(graph_result: dict[str, Any]) -> list[dict[str, Any]]:
|
||
products: list[dict[str, Any]] = []
|
||
for row in graph_result.get("rows") or []:
|
||
if not isinstance(row, list) or len(row) < 4:
|
||
continue
|
||
product_name = str(row[0] or "").strip()
|
||
if not product_name:
|
||
continue
|
||
plans: list[dict[str, Any]] = []
|
||
for raw_plan in row[3] if isinstance(row[3], list) else []:
|
||
if not isinstance(raw_plan, dict):
|
||
continue
|
||
if not any(raw_plan.get(k) not in (None, "") for k in (
|
||
"plan_name", "display_name", "adult_price_min", "adult_price_max",
|
||
"child_price_min", "child_price_max", "single_room_diff_min",
|
||
"single_room_diff_max",
|
||
)):
|
||
continue
|
||
plans.append(raw_plan)
|
||
products.append({
|
||
"product_name": product_name,
|
||
"product_id": row[1] if len(row) > 1 else "",
|
||
"duration_days": row[2] if len(row) > 2 else None,
|
||
"plans": plans,
|
||
})
|
||
return products
|
||
|
||
|
||
def _route_list_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str] | None:
|
||
if not _is_route_list_question(question):
|
||
return None
|
||
items = _route_items_from_rows(graph_result)
|
||
if not items:
|
||
return None
|
||
lines = [
|
||
f"当前图谱共查到 {len(items)} 条旅行线路：",
|
||
*[
|
||
f"{idx}. {item['name']}" + (f"（{item['duration_days']}日）" if item.get("duration_days") else "")
|
||
for idx, item in enumerate(items, start=1)
|
||
],
|
||
"如需进一步报价，请继续指定线路名称、出发日期、人数和住宿偏好。",
|
||
]
|
||
answer = "\n".join(lines)
|
||
preview_items = items[:10]
|
||
customer = "目前可查到 " + str(len(items)) + " 条旅行线路，主要包括：" + "、".join(
|
||
item["name"] + (f"（{item['duration_days']}日）" if item.get("duration_days") else "")
|
||
for item in preview_items
|
||
)
|
||
if len(items) > len(preview_items):
|
||
customer += f"等，剩余 {len(items) - len(preview_items)} 条可继续筛选。"
|
||
else:
|
||
customer += "。"
|
||
customer += "您想看哪条线路的价格、行程或余位？"
|
||
return answer, customer
|
||
|
||
|
||
def _price_template_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
products = _price_plans_from_rows(graph_result)
|
||
if not products:
|
||
return None
|
||
|
||
lines = [f"已在图谱中匹配到 {len(products)} 条相关线路报价："]
|
||
evidence: list[dict[str, str]] = []
|
||
plans: list[dict[str, Any]] = []
|
||
for idx, product in enumerate(products[:8], start=1):
|
||
title = str(product["product_name"])
|
||
day_suffix = f"（{product['duration_days']}日）" if product.get("duration_days") else ""
|
||
plan_lines: list[str] = []
|
||
for plan in product["plans"][:8]:
|
||
plan_name = str(plan.get("display_name") or plan.get("plan_name") or "默认报价档位")
|
||
adult = _money_range(plan.get("adult_price_min"), plan.get("adult_price_max"))
|
||
child = _money_range(plan.get("child_price_min"), plan.get("child_price_max"))
|
||
room = _money_range(plan.get("single_room_diff_min"), plan.get("single_room_diff_max"), "元")
|
||
parts = [plan_name]
|
||
if adult:
|
||
parts.append(f"成人 {adult}")
|
||
if child:
|
||
parts.append(f"儿童 {child}")
|
||
if room:
|
||
parts.append(f"单房差 {room}")
|
||
plan_lines.append("，".join(parts))
|
||
if not plan_lines:
|
||
plan_lines.append("图谱暂未录入明确报价档位，需要按团期核价")
|
||
lines.append(f"{idx}. {title}{day_suffix}：" + "；".join(plan_lines))
|
||
summary = "；".join(plan_lines)[:360]
|
||
evidence.append({
|
||
"type": "报价证据",
|
||
"name": title[:120],
|
||
"summary": summary,
|
||
"source": "FalkorDB 图查询 ProductPricePlan",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "线路报价",
|
||
"plan_name": title,
|
||
"product_name": title,
|
||
"fit_score": max(60, 96 - idx * 3),
|
||
"match_reasons": ["命中线路名称/天数", "读取 ProductPricePlan 报价档位"],
|
||
"route_summary": f"{title}{day_suffix}",
|
||
"quote_summary": summary,
|
||
"variant_summary": summary,
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_price_template",
|
||
})
|
||
lines.append("以上为图谱报价档位，最终价格、余位、房型和儿童口径需要按具体出发日期二次核实。")
|
||
answer = "\n".join(lines)
|
||
first = products[0]
|
||
first_plans = first.get("plans") or []
|
||
if first_plans:
|
||
plan = first_plans[0]
|
||
adult = _money_range(plan.get("adult_price_min"), plan.get("adult_price_max"))
|
||
child = _money_range(plan.get("child_price_min"), plan.get("child_price_max"))
|
||
bits = [str(first["product_name"])]
|
||
if adult:
|
||
bits.append(f"成人参考 {adult}")
|
||
if child:
|
||
bits.append(f"儿童参考 {child}")
|
||
customer = "，".join(bits) + "。具体价格和余位需要按出发日期、人数、住宿档位再核实。"
|
||
else:
|
||
customer = f"已匹配到 {first['product_name']}，但图谱暂未给出明确报价档位，需要按出发日期和人数核价。"
|
||
return answer, customer, evidence, plans
|
||
|
||
|
||
def _non_empty_maps(value: Any) -> list[dict[str, Any]]:
|
||
if not isinstance(value, list):
|
||
return []
|
||
out: list[dict[str, Any]] = []
|
||
for item in value:
|
||
if isinstance(item, dict) and any(v not in (None, "") for v in item.values()):
|
||
out.append(item)
|
||
return out
|
||
|
||
|
||
def _route_match_score(question: str, product: dict[str, Any]) -> int:
|
||
name = str(product.get("product_name") or "")
|
||
score = 0
|
||
for term in _route_name_terms(question):
|
||
if term and term in name:
|
||
score += 12
|
||
for term in _route_feature_terms(question):
|
||
if term and term in name:
|
||
score += 18
|
||
match = re.search(r"(\d+)\s*(?:日|天)", question)
|
||
if match and _safe_int(product.get("duration_days"), 0) == int(match.group(1)):
|
||
score += 15
|
||
for chinese, value in {"一": 1, "二": 2, "两": 2, "三": 3, "四": 4, "五": 5}.items():
|
||
if (f"{chinese}日" in question or f"{chinese}天" in question) and _safe_int(product.get("duration_days"), 0) == value:
|
||
score += 15
|
||
return score
|
||
|
||
|
||
def _route_multihop_products_from_rows(question: str, graph_result: dict[str, Any]) -> list[dict[str, Any]]:
|
||
products: list[dict[str, Any]] = []
|
||
for row in graph_result.get("rows") or []:
|
||
if not isinstance(row, list) or len(row) < 6:
|
||
continue
|
||
product = {
|
||
"product_name": str(row[0] or "").strip(),
|
||
"product_id": row[1] if len(row) > 1 else "",
|
||
"duration_days": row[2] if len(row) > 2 else None,
|
||
"price_plans": _non_empty_maps(row[3]),
|
||
"route_points": _non_empty_maps(row[4]),
|
||
"nearby_hotels": _non_empty_maps(row[5]),
|
||
}
|
||
if product["product_name"]:
|
||
product["match_score"] = _route_match_score(question, product)
|
||
products.append(product)
|
||
products.sort(key=lambda item: (item.get("match_score") or 0, -_safe_int(item.get("duration_days"), 99)), reverse=True)
|
||
return products
|
||
|
||
|
||
def _aggregate_price_text(plans: list[dict[str, Any]]) -> tuple[str, str, str]:
|
||
adult_lows: list[float] = []
|
||
adult_highs: list[float] = []
|
||
child_lows: list[float] = []
|
||
child_highs: list[float] = []
|
||
for plan in plans:
|
||
for bucket, key in ((adult_lows, "adult_price_min"), (adult_highs, "adult_price_max"), (child_lows, "child_price_min"), (child_highs, "child_price_max")):
|
||
try:
|
||
value = float(plan.get(key))
|
||
except Exception:
|
||
continue
|
||
if value > 0:
|
||
bucket.append(value)
|
||
adult = _money_range(min(adult_lows) if adult_lows else None, max(adult_highs) if adult_highs else None)
|
||
child = _money_range(min(child_lows) if child_lows else None, max(child_highs) if child_highs else None)
|
||
samples: list[str] = []
|
||
for plan in plans[:5]:
|
||
name = str(plan.get("display_name") or plan.get("plan_name") or "报价档位").strip()
|
||
adult_item = _money_range(plan.get("adult_price_min"), plan.get("adult_price_max"))
|
||
child_item = _money_range(plan.get("child_price_min"), plan.get("child_price_max"))
|
||
parts = [name]
|
||
if adult_item:
|
||
parts.append(f"成人 {adult_item}")
|
||
if child_item:
|
||
parts.append(f"儿童 {child_item}")
|
||
samples.append("，".join(parts))
|
||
return adult, child, "；".join(samples)
|
||
|
||
|
||
def _route_point_key(point: dict[str, Any]) -> tuple[int, int, str]:
|
||
return (
|
||
_safe_int(point.get("day"), 99),
|
||
_safe_int(point.get("sequence"), 99),
|
||
str(point.get("attraction_name") or point.get("stop_name") or ""),
|
||
)
|
||
|
||
|
||
def _is_non_scenic_route_node(name: str) -> bool:
|
||
compact = re.sub(r"\s+", "", name)
|
||
if any(term in compact for term in ("送机", "送站", "接机", "接站", "机场", "高铁站", "火车站", "散团", "集合")):
|
||
return True
|
||
if compact in {"贵阳", "安顺", "贵阳/安顺", "贵阳安顺"}:
|
||
return True
|
||
return bool(re.fullmatch(r"(贵阳|安顺|遵义|凯里|铜仁|荔波|西江)(/|、)(贵阳|安顺|遵义|凯里|铜仁|荔波|西江)", compact))
|
||
|
||
|
||
def _route_scenic_names(points: list[dict[str, Any]], limit: int = 12) -> list[str]:
|
||
out: list[str] = []
|
||
for point in sorted(points, key=_route_point_key):
|
||
name = str(point.get("attraction_name") or point.get("stop_name") or "").strip()
|
||
if _is_non_scenic_route_node(name):
|
||
continue
|
||
if name and name not in out:
|
||
out.append(name)
|
||
if len(out) >= limit:
|
||
break
|
||
return out
|
||
|
||
|
||
def _hotel_sort_key(item: dict[str, Any]) -> tuple[int, float, str]:
|
||
rank = _safe_int(item.get("recommend_rank"), 999)
|
||
try:
|
||
distance = float(item.get("driving_distance_km"))
|
||
except Exception:
|
||
distance = 9999.0
|
||
return rank, distance, str(item.get("hotel_name") or "")
|
||
|
||
|
||
def _filter_hotels(question: str, hotels: list[dict[str, Any]], limit: int = 8) -> list[dict[str, Any]]:
|
||
hints = _scenic_hint_terms(question)
|
||
out: list[dict[str, Any]] = []
|
||
seen: set[str] = set()
|
||
for item in sorted(hotels, key=_hotel_sort_key):
|
||
hotel_name = str(item.get("hotel_name") or "").strip()
|
||
if not hotel_name:
|
||
continue
|
||
scenic_text = " ".join(str(item.get(field) or "") for field in ("scenic_name", "stop_name", "county", "city", "address"))
|
||
if hints and not any(hint and hint in scenic_text for hint in hints):
|
||
continue
|
||
key = f"{item.get('scenic_name') or item.get('stop_name')}|{hotel_name}"
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
out.append(item)
|
||
if len(out) >= limit:
|
||
break
|
||
if out or hints:
|
||
return out
|
||
for item in sorted(hotels, key=_hotel_sort_key):
|
||
hotel_name = str(item.get("hotel_name") or "").strip()
|
||
if not hotel_name:
|
||
continue
|
||
key = f"{item.get('scenic_name') or item.get('stop_name')}|{hotel_name}"
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
out.append(item)
|
||
if len(out) >= limit:
|
||
break
|
||
return out
|
||
|
||
|
||
def _hotel_line(item: dict[str, Any]) -> str:
|
||
name = str(item.get("hotel_name") or "").strip()
|
||
scenic = str(item.get("scenic_name") or item.get("stop_name") or "相关景区").strip()
|
||
star = str(item.get("star_rating") or "").strip()
|
||
location = " ".join(str(item.get(field) or "").strip() for field in ("county", "address") if item.get(field)).strip()
|
||
distance = _money(item.get("driving_distance_km"))
|
||
minutes = _money(item.get("driving_time_minutes"))
|
||
parts = [name]
|
||
if star:
|
||
parts.append(star)
|
||
if distance:
|
||
parts.append(f"距{scenic}约{distance}km")
|
||
if minutes:
|
||
parts.append(f"车程约{minutes}分钟")
|
||
if location:
|
||
parts.append(location)
|
||
return "，".join(parts)
|
||
|
||
|
||
def _route_multihop_template_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
products = _route_multihop_products_from_rows(question, graph_result)
|
||
if not products:
|
||
return None
|
||
product = products[0]
|
||
product_name = str(product["product_name"])
|
||
day_text = f"{product['duration_days']}天" if product.get("duration_days") else "天数待核实"
|
||
adult_price, child_price, price_samples = _aggregate_price_text(product["price_plans"])
|
||
scenic_names = _route_scenic_names(product["route_points"])
|
||
hotels = _filter_hotels(question, product["nearby_hotels"], limit=8)
|
||
|
||
price_parts = []
|
||
if adult_price:
|
||
price_parts.append(f"成人参考 {adult_price}")
|
||
if child_price:
|
||
price_parts.append(f"儿童参考 {child_price}")
|
||
price_text = "，".join(price_parts) or "图谱暂未录入明确报价档位"
|
||
scenic_text = "、".join(scenic_names) if scenic_names else "图谱暂未查到明确途经景区"
|
||
hotel_texts = [_hotel_line(item) for item in hotels[:6]]
|
||
if hotel_texts:
|
||
hotel_text = "；".join(hotel_texts)
|
||
elif _scenic_hint_terms(question):
|
||
hotel_text = "该景区附近酒店证据不足，需要按具体入住地再核实。"
|
||
else:
|
||
hotel_text = "请指定一个景区后，我可以继续筛选附近可住酒店。"
|
||
|
||
lines = [
|
||
f"已按百姓惠图谱匹配到线路：{product_name}。",
|
||
f"1. 游玩天数：{day_text}。",
|
||
f"2. 参考价格：{price_text}。",
|
||
f"3. 期间可去景区/节点：{scenic_text}。",
|
||
f"4. 附近酒店参考：{hotel_text}",
|
||
]
|
||
if price_samples:
|
||
lines.append(f"报价档位示例：{price_samples}。")
|
||
lines.append("以上为图谱证据口径，最终价格、房型、余位、入住酒店和景区政策需按出发日期二次核实。")
|
||
answer = "\n".join(lines)
|
||
|
||
customer_bits = [f"{product_name} 是 {day_text}线路"]
|
||
if price_text:
|
||
customer_bits.append(price_text)
|
||
if scenic_names:
|
||
customer_bits.append("可玩 " + "、".join(scenic_names[:5]))
|
||
if hotels:
|
||
customer_bits.append("附近可参考 " + "、".join(str(item.get("hotel_name") or "") for item in hotels[:3] if item.get("hotel_name")))
|
||
customer_reply = "亲，" + "；".join(customer_bits) + "。具体价格、房型和余位需要按出发日期再确认。"
|
||
|
||
evidence = [
|
||
{
|
||
"type": "线路证据",
|
||
"name": product_name[:120],
|
||
"summary": f"{product_name}；{day_text}；{price_text}",
|
||
"source": "FalkorDB 图查询 TourProduct/ProductPricePlan",
|
||
},
|
||
{
|
||
"type": "行程景区证据",
|
||
"name": "途经景区",
|
||
"summary": scenic_text[:360],
|
||
"source": "FalkorDB 图查询 ProductDay/RouteStop/ScenicAttraction",
|
||
},
|
||
]
|
||
if hotel_texts:
|
||
evidence.append({
|
||
"type": "酒店证据",
|
||
"name": "景区附近酒店",
|
||
"summary": "；".join(hotel_texts[:4])[:360],
|
||
"source": "FalkorDB 图查询 ATTRACTION_NEARBY_HOTEL/Hotel",
|
||
})
|
||
plans = [{
|
||
"rank": 1,
|
||
"label": "线路多跳问答",
|
||
"plan_name": product_name,
|
||
"product_name": product_name,
|
||
"fit_score": 94,
|
||
"match_reasons": ["命中线路实体", "读取报价、天数、景区和附近酒店多跳证据"],
|
||
"route_summary": f"{product_name}；{day_text}；{scenic_text}",
|
||
"quote_summary": price_text,
|
||
"variant_summary": hotel_text,
|
||
"daily_itinerary": [
|
||
{
|
||
"day": point.get("day"),
|
||
"title": point.get("attraction_name") or point.get("stop_name"),
|
||
"summary": point.get("stop_name") or "",
|
||
}
|
||
for point in sorted(product["route_points"], key=_route_point_key)[:12]
|
||
if point.get("attraction_name") or point.get("stop_name")
|
||
],
|
||
"hotels": [
|
||
{
|
||
"name": item.get("hotel_name"),
|
||
"scenic_name": item.get("scenic_name") or item.get("stop_name"),
|
||
"summary": _hotel_line(item),
|
||
}
|
||
for item in hotels[:6]
|
||
],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_route_multihop_template",
|
||
}]
|
||
return answer, customer_reply, evidence, plans
|
||
|
||
|
||
def _valid_travel_item(item: Any) -> bool:
|
||
return isinstance(item, dict) and bool(str(item.get("name") or "").strip())
|
||
|
||
|
||
def _dedupe_travel_items(items: list[dict[str, Any]], limit: int = 18) -> list[dict[str, Any]]:
|
||
out: list[dict[str, Any]] = []
|
||
seen: set[str] = set()
|
||
for item in items:
|
||
if not _valid_travel_item(item):
|
||
continue
|
||
key = "|".join(str(item.get(field) or "") for field in ("name", "price", "adult_price", "unit", "status"))
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
out.append(item)
|
||
if len(out) >= limit:
|
||
break
|
||
return out
|
||
|
||
|
||
def _fee_products_from_rows(graph_result: dict[str, Any]) -> list[dict[str, Any]]:
|
||
products: list[dict[str, Any]] = []
|
||
for row in graph_result.get("rows") or []:
|
||
if not isinstance(row, list) or len(row) < 6:
|
||
continue
|
||
items: list[dict[str, Any]] = []
|
||
for group in row[3:6]:
|
||
if isinstance(group, list):
|
||
items.extend(item for item in group if isinstance(item, dict))
|
||
products.append({
|
||
"product_name": str(row[0] or "").strip(),
|
||
"product_id": row[1] if len(row) > 1 else "",
|
||
"duration_days": row[2] if len(row) > 2 else None,
|
||
"items": _dedupe_travel_items(items),
|
||
})
|
||
return [product for product in products if product["product_name"] and product["items"]]
|
||
|
||
|
||
def _item_price_text(item: dict[str, Any]) -> str:
|
||
price = _money(item.get("adult_price") or item.get("price"))
|
||
unit = str(item.get("unit") or "人").strip()
|
||
if price:
|
||
return f"{price}元/{unit}"
|
||
return "需核价"
|
||
|
||
|
||
def _fee_template_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
products = _fee_products_from_rows(graph_result)
|
||
if not products:
|
||
return None
|
||
|
||
lines = [f"已在图谱中匹配到 {len(products)} 条线路的费用/小交通项目："]
|
||
evidence: list[dict[str, str]] = []
|
||
plans: list[dict[str, Any]] = []
|
||
for idx, product in enumerate(products[:6], start=1):
|
||
title = product["product_name"]
|
||
day_suffix = f"（{product['duration_days']}日）" if product.get("duration_days") else ""
|
||
item_texts: list[str] = []
|
||
for item in product["items"][:10]:
|
||
item_text = f"{item.get('name')}：{_item_price_text(item)}"
|
||
status = str(item.get("status") or item.get("default_status") or "").strip()
|
||
if status:
|
||
item_text += f"（{status}）"
|
||
item_texts.append(item_text)
|
||
summary = "；".join(item_texts)
|
||
lines.append(f"{idx}. {title}{day_suffix}：" + summary)
|
||
evidence.append({
|
||
"type": "费用证据",
|
||
"name": title[:120],
|
||
"summary": summary[:360],
|
||
"source": "FalkorDB 图查询 TravelItem",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "费用/小交通",
|
||
"plan_name": title,
|
||
"product_name": title,
|
||
"fit_score": max(60, 94 - idx * 3),
|
||
"match_reasons": ["命中线路名称/天数", "读取 TravelItem 费用项目"],
|
||
"route_summary": f"{title}{day_suffix}",
|
||
"quote_summary": summary[:360],
|
||
"variant_summary": summary[:360],
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_fee_template",
|
||
})
|
||
lines.append("以上项目按图谱记录展示，景区门票、小交通和可选项目需按团期及景区政策二次核实。")
|
||
answer = "\n".join(lines)
|
||
first = products[0]
|
||
preview = "；".join(f"{item.get('name')} {_item_price_text(item)}" for item in first["items"][:4])
|
||
customer = f"{first['product_name']} 相关费用项目包括：{preview}。具体是否必含、是否可选和儿童政策需要按团期再核实。"
|
||
return answer, customer, evidence, plans
|
||
|
||
|
||
def _vehicle_items_from_rows(graph_result: dict[str, Any]) -> list[dict[str, Any]]:
|
||
items: list[dict[str, Any]] = []
|
||
for row in graph_result.get("rows") or []:
|
||
if not isinstance(row, list) or not row:
|
||
continue
|
||
name = str(row[0] or "").strip()
|
||
if not name:
|
||
continue
|
||
items.append({
|
||
"name": name,
|
||
"type": row[1] if len(row) > 1 else "",
|
||
"subtype": row[2] if len(row) > 2 else "",
|
||
"price": row[3] if len(row) > 3 else None,
|
||
"unit": row[4] if len(row) > 4 else "",
|
||
"raw_evidence": row[5] if len(row) > 5 else "",
|
||
})
|
||
return _dedupe_travel_items(items, limit=30)
|
||
|
||
|
||
def _vehicle_template_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
items = _vehicle_items_from_rows(graph_result)
|
||
if not items:
|
||
return None
|
||
lines = [
|
||
f"当前图谱查到 {len(items)} 个用车/车型相关项目：",
|
||
*[
|
||
f"{idx}. {item['name']}" + (f"：{_item_price_text(item)}" if item.get("price") not in (None, "") else "")
|
||
for idx, item in enumerate(items, start=1)
|
||
],
|
||
"具体车型是否可用、座位数、车辆档位和结算口径需要按团期及供应商确认。",
|
||
]
|
||
answer = "\n".join(lines)
|
||
preview = "、".join(
|
||
item["name"] + (f"（{_item_price_text(item)}）" if item.get("price") not in (None, "") else "")
|
||
for item in items[:8]
|
||
)
|
||
customer = f"目前图谱里可查到 {len(items)} 个用车相关项目，主要包括：{preview}。具体车辆安排需按出发日期、人数和供应商确认。"
|
||
evidence = [
|
||
{
|
||
"type": "用车证据",
|
||
"name": item["name"][:120],
|
||
"summary": f"{item.get('subtype') or item.get('type') or '用车项目'}；参考价：{_item_price_text(item)}",
|
||
"source": "FalkorDB 图查询 TravelItem",
|
||
}
|
||
for item in items[:12]
|
||
]
|
||
plans = [
|
||
{
|
||
"rank": idx,
|
||
"label": "用车项目",
|
||
"plan_name": item["name"],
|
||
"product_name": item["name"],
|
||
"fit_score": max(60, 92 - idx),
|
||
"match_reasons": ["用车/车型快查", "读取 TravelItem"],
|
||
"route_summary": item["name"],
|
||
"quote_summary": _item_price_text(item),
|
||
"variant_summary": str(item.get("subtype") or ""),
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_vehicle_template",
|
||
}
|
||
for idx, item in enumerate(items[:4], start=1)
|
||
]
|
||
return answer, customer, evidence, plans
|
||
|
||
|
||
def _context_products_from_rows(graph_result: dict[str, Any]) -> list[dict[str, Any]]:
|
||
products: list[dict[str, Any]] = []
|
||
for row in graph_result.get("rows") or []:
|
||
if not isinstance(row, list) or len(row) < 5:
|
||
continue
|
||
name = str(row[0] or "").strip()
|
||
if not name:
|
||
continue
|
||
price_plans = [item for item in row[3] if isinstance(item, dict)] if isinstance(row[3], list) else []
|
||
route_points = [item for item in row[4] if isinstance(item, dict)] if isinstance(row[4], list) else []
|
||
min_price = None
|
||
for plan in price_plans:
|
||
value = plan.get("adult_price_min")
|
||
if isinstance(value, (int, float)):
|
||
min_price = value if min_price is None else min(min_price, value)
|
||
scenic_names = _route_scenic_names(route_points, limit=30)
|
||
attraction_count = len(scenic_names)
|
||
products.append({
|
||
"product_name": name,
|
||
"product_id": row[1] if len(row) > 1 else "",
|
||
"duration_days": row[2] if len(row) > 2 else None,
|
||
"adult_price_min": min_price,
|
||
"price_plans": price_plans[:8],
|
||
"route_points": route_points[:16],
|
||
"scenic_names": scenic_names,
|
||
"attraction_count": attraction_count,
|
||
})
|
||
return products
|
||
|
||
|
||
def _condition_route_score(question: str, product: dict[str, Any]) -> tuple[int, int, int]:
|
||
name = str(product.get("product_name") or "")
|
||
duration = _safe_int(product.get("duration_days"), 99)
|
||
price = product.get("adult_price_min")
|
||
price_int = _safe_int(price, 999999) if price not in (None, "") else 999999
|
||
scenic_count = _safe_int(product.get("attraction_count"), len(product.get("scenic_names") or []))
|
||
scenic_text = " ".join(product.get("scenic_names") or [])
|
||
slots = _condition_slots(question)
|
||
score = 50
|
||
if slots["family"]:
|
||
if any(term in name for term in ("亲子", "轻奢", "纯玩", "小包团", "2+1", "私家")):
|
||
score += 18
|
||
if duration <= 3:
|
||
score += 10
|
||
elif duration <= 4:
|
||
score += 6
|
||
if slots["comfort"]:
|
||
if any(term in name for term in ("轻奢", "纯玩", "2+1", "私家", "头等舱")):
|
||
score += 20
|
||
if duration <= 3:
|
||
score += 12
|
||
if 0 < scenic_count <= 5:
|
||
score += 6
|
||
if duration >= 5:
|
||
score -= 8
|
||
if "梵净山" in scenic_text:
|
||
score -= 8
|
||
if slots["budget"]:
|
||
if price_int <= 800:
|
||
score += 18
|
||
elif price_int <= 1200:
|
||
score += 10
|
||
if any(term in name for term in ("购物", "特价购物")):
|
||
score -= 12
|
||
return score, -duration, -price_int
|
||
|
||
|
||
def _condition_route_template_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
products = _context_products_from_rows(graph_result)
|
||
if not products:
|
||
return None
|
||
products.sort(key=lambda item: _condition_route_score(question, item), reverse=True)
|
||
selected = products[:5]
|
||
lines = ["按“老人/小孩/轻松/预算”等条件从图谱中筛出以下候选线路："]
|
||
evidence: list[dict[str, str]] = []
|
||
plans: list[dict[str, Any]] = []
|
||
for idx, product in enumerate(selected, start=1):
|
||
name = product["product_name"]
|
||
duration = f"{product['duration_days']}日" if product.get("duration_days") else "天数待核实"
|
||
price = _money(product.get("adult_price_min"))
|
||
price_text = f"成人起价约 {price}元/人" if price else "价格需按团期核实"
|
||
scenic_names = product.get("scenic_names") or _route_scenic_names(product.get("route_points") or [], limit=8)
|
||
scenic_text = "、".join(scenic_names[:5]) if scenic_names else "景区信息待核实"
|
||
reasons: list[str] = []
|
||
if any(term in name for term in ("轻奢", "纯玩", "2+1", "私家", "小包团")):
|
||
reasons.append("线路名称体现舒适/纯玩/小团倾向")
|
||
if _safe_int(product.get("duration_days"), 99) <= 3:
|
||
reasons.append("天数较短，行程压力相对低")
|
||
if price:
|
||
reasons.append("图谱有报价起价可参考")
|
||
reason_text = "；".join(reasons[:3]) or "图谱有线路、价格和行程证据"
|
||
line = f"{idx}. {name}（{duration}）：{price_text}；可玩 {scenic_text}；推荐依据：{reason_text}"
|
||
lines.append(line)
|
||
evidence.append({
|
||
"type": "条件筛选证据",
|
||
"name": name[:120],
|
||
"summary": line[:360],
|
||
"source": "FalkorDB 图查询 TourProduct/ProductPricePlan/ScenicAttraction",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "条件推荐线路",
|
||
"plan_name": name,
|
||
"product_name": name,
|
||
"fit_score": max(60, min(96, _condition_route_score(question, product)[0])),
|
||
"match_reasons": reasons or ["条件筛选命中", "读取线路报价和景区证据"],
|
||
"route_summary": f"{name}（{duration}）：{scenic_text}",
|
||
"quote_summary": price_text,
|
||
"variant_summary": reason_text,
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_condition_route_advice",
|
||
})
|
||
best = selected[0]
|
||
best_price = _money(best.get("adult_price_min"))
|
||
best_price_text = f"，成人起价约 {best_price}元/人" if best_price else ""
|
||
best_duration = f"{best['duration_days']}日" if best.get("duration_days") else "天数待核实"
|
||
customer = f"亲，带老人小孩又希望轻松，可以优先看 {best['product_name']}（{best_duration}{best_price_text}）。它在图谱里有线路和景区证据，最终还要按出发日期、人数和住宿档位核实。"
|
||
lines.append("这些推荐是基于图谱字段做的初筛，不等于最终承诺；老人/儿童还需要二次确认行程强度、用车、住宿和余位。")
|
||
return "\n".join(lines), customer, evidence, plans
|
||
|
||
|
||
def _route_compare_suitability_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
products = _context_products_from_rows(graph_result)
|
||
if not products:
|
||
return None
|
||
compare_terms = _route_name_terms(question)
|
||
grouped: list[dict[str, Any]] = []
|
||
for term in compare_terms:
|
||
candidates = [item for item in products if term in str(item.get("product_name") or "")]
|
||
if not candidates:
|
||
continue
|
||
other_terms = [other for other in compare_terms if other != term]
|
||
pure_candidates = [
|
||
item for item in candidates
|
||
if not any(other in str(item.get("product_name") or "") for other in other_terms)
|
||
]
|
||
pool = pure_candidates or candidates
|
||
pool.sort(key=lambda item: _condition_route_score(question, item), reverse=True)
|
||
best = pool[0]
|
||
grouped.append({
|
||
"term": term,
|
||
"best": best,
|
||
"score": _condition_route_score(question, best)[0],
|
||
})
|
||
if len(grouped) < 2:
|
||
return None
|
||
|
||
grouped.sort(key=lambda item: item["score"], reverse=True)
|
||
winner = grouped[0]
|
||
lines = ["按老人/儿童/轻松度条件，用图谱中的天数、价格和景区节点做适配度对比："]
|
||
evidence: list[dict[str, str]] = []
|
||
plans: list[dict[str, Any]] = []
|
||
for idx, group in enumerate(grouped, start=1):
|
||
product = group["best"]
|
||
name = product["product_name"]
|
||
duration = f"{product['duration_days']}日" if product.get("duration_days") else "天数待核实"
|
||
price = _money(product.get("adult_price_min"))
|
||
price_text = f"成人起价约 {price}元/人" if price else "价格需按团期核实"
|
||
scenic_names = product.get("scenic_names") or []
|
||
scenic_text = "、".join(scenic_names[:6]) if scenic_names else "景区信息待核实"
|
||
reasons: list[str] = []
|
||
if _safe_int(product.get("duration_days"), 99) <= 3:
|
||
reasons.append("天数短，行程压力相对低")
|
||
if any(term in name for term in ("轻奢", "2+1", "纯玩", "头等舱", "私家")):
|
||
reasons.append("名称体现舒适/纯玩/车型优势")
|
||
if "梵净山" in scenic_text:
|
||
reasons.append("包含梵净山，老人小孩需评估体力")
|
||
if price:
|
||
reasons.append("有报价起价可参考")
|
||
reason_text = "；".join(reasons[:4]) or "有线路、价格和景区证据"
|
||
line = f"{idx}. {group['term']}：代表线路 {name}（{duration}），{price_text}；景区：{scenic_text}；判断：{reason_text}"
|
||
lines.append(line)
|
||
evidence.append({
|
||
"type": "适配度对比证据",
|
||
"name": str(group["term"])[:120],
|
||
"summary": line[:360],
|
||
"source": "FalkorDB 图查询 TourProduct/ProductPricePlan/ScenicAttraction",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "线路适配度对比",
|
||
"plan_name": str(group["term"]),
|
||
"product_name": name,
|
||
"fit_score": max(60, min(96, int(group["score"]))),
|
||
"match_reasons": reasons or ["条件适配评分", "读取线路报价和景区证据"],
|
||
"route_summary": line,
|
||
"quote_summary": price_text,
|
||
"variant_summary": reason_text,
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_route_compare_suitability",
|
||
})
|
||
|
||
winner_product = winner["best"]
|
||
customer = f"亲，按老人小孩和不要太累的条件，优先建议 {winner['term']}，代表线路可看 {winner_product['product_name']}。它在图谱评分里更偏轻松/舒适；最终还要按出发日期、人数、住宿和老人儿童体力二次确认。"
|
||
lines.append("该结论是图谱条件评分，不是最终承诺；涉及老人儿童时建议再核实步行强度、用车、住宿和景区政策。")
|
||
return "\n".join(lines), customer, evidence, plans
|
||
|
||
|
||
def _route_compare_scenic_count_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]] | None:
|
||
products = _context_products_from_rows(graph_result)
|
||
if not products:
|
||
return None
|
||
compare_terms = _route_name_terms(question)
|
||
grouped: list[dict[str, Any]] = []
|
||
for term in compare_terms:
|
||
candidates = [item for item in products if term in str(item.get("product_name") or "")]
|
||
if not candidates:
|
||
continue
|
||
other_terms = [other for other in compare_terms if other != term]
|
||
pure_candidates = [
|
||
item for item in candidates
|
||
if not any(other in str(item.get("product_name") or "") for other in other_terms)
|
||
]
|
||
pool = pure_candidates or candidates
|
||
pool.sort(key=lambda item: (_safe_int(item.get("attraction_count"), 0), _route_match_score(question, item)), reverse=True)
|
||
best = pool[0]
|
||
grouped.append({
|
||
"term": term,
|
||
"best": best,
|
||
"count": _safe_int(best.get("attraction_count"), 0),
|
||
"candidates": pool[:4],
|
||
})
|
||
if grouped:
|
||
selected = [item["best"] for item in grouped]
|
||
else:
|
||
products.sort(key=lambda item: (_route_match_score(question, item), _safe_int(item.get("attraction_count"), 0)), reverse=True)
|
||
selected = products[:8]
|
||
max_count = max(_safe_int(item.get("attraction_count"), 0) for item in selected)
|
||
winners = [item for item in selected if _safe_int(item.get("attraction_count"), 0) == max_count and max_count > 0]
|
||
lines = ["按当前图谱的 ScenicAttraction 证据统计："]
|
||
evidence: list[dict[str, str]] = []
|
||
plans: list[dict[str, Any]] = []
|
||
if grouped:
|
||
for idx, group in enumerate(grouped, start=1):
|
||
product = group["best"]
|
||
scenic_names = product.get("scenic_names") or _route_scenic_names(product.get("route_points") or [], limit=10)
|
||
count = _safe_int(product.get("attraction_count"), len(scenic_names))
|
||
scenic_text = "、".join(scenic_names[:8]) if scenic_names else "暂无明确景区证据"
|
||
line = f"{idx}. {group['term']}：代表线路 {product['product_name']}，图谱命中 {count} 个景区/游玩节点，包含 {scenic_text}"
|
||
lines.append(line)
|
||
evidence.append({
|
||
"type": "景区数量对比证据",
|
||
"name": str(group["term"])[:120],
|
||
"summary": line[:360],
|
||
"source": "FalkorDB 图查询 ProductDay/RouteStop/ScenicAttraction",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "线路景点数量对比",
|
||
"plan_name": str(group["term"]),
|
||
"product_name": product["product_name"],
|
||
"fit_score": max(60, 92 - idx * 3),
|
||
"match_reasons": ["按用户提到的线路词分组", "统计 ScenicAttraction 去重数量"],
|
||
"route_summary": line,
|
||
"quote_summary": "",
|
||
"variant_summary": scenic_text,
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_route_compare_scenic_count",
|
||
})
|
||
else:
|
||
for idx, product in enumerate(selected, start=1):
|
||
scenic_names = product.get("scenic_names") or _route_scenic_names(product.get("route_points") or [], limit=10)
|
||
count = _safe_int(product.get("attraction_count"), len(scenic_names))
|
||
scenic_text = "、".join(scenic_names[:8]) if scenic_names else "暂无明确景区证据"
|
||
line = f"{idx}. {product['product_name']}：图谱命中 {count} 个景区/游玩节点，包含 {scenic_text}"
|
||
lines.append(line)
|
||
evidence.append({
|
||
"type": "景区数量对比证据",
|
||
"name": product["product_name"][:120],
|
||
"summary": line[:360],
|
||
"source": "FalkorDB 图查询 ProductDay/RouteStop/ScenicAttraction",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "线路景点数量对比",
|
||
"plan_name": product["product_name"],
|
||
"product_name": product["product_name"],
|
||
"fit_score": max(60, 92 - idx * 3),
|
||
"match_reasons": ["线路名称命中", "统计 ScenicAttraction 去重数量"],
|
||
"route_summary": line,
|
||
"quote_summary": "",
|
||
"variant_summary": scenic_text,
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_route_compare_scenic_count",
|
||
})
|
||
if winners:
|
||
if len(winners) > 1 and grouped:
|
||
winner_names = "、".join(
|
||
group["term"] for group in grouped if group["best"] in winners
|
||
)
|
||
customer = f"从当前图谱景区数量看，{winner_names} 最高都约 {max_count} 个景区/游玩节点，数量接近；建议再结合天数、价格和行程强度选择。"
|
||
elif grouped:
|
||
winner_name = next((group["term"] for group in grouped if group["best"] in winners), "")
|
||
customer = f"从当前图谱景区数量看，{winner_name or winners[0]['product_name']}的代表线路命中的景区/游玩节点更多（约 {max_count} 个）。具体还要结合出发日期、行程强度和实际游玩安排确认。"
|
||
else:
|
||
winner_names = "、".join(item["product_name"] for item in winners[:2])
|
||
customer = f"从当前图谱景区数量看，{winner_names} 命中的景区/游玩节点更多（约 {max_count} 个）。具体还要结合出发日期、行程强度和实际游玩安排确认。"
|
||
else:
|
||
customer = "当前图谱没有足够的景区数量证据做可靠比较，建议补充具体线路名称或让后台核实行程明细。"
|
||
lines.append("注意：这里比较的是图谱已结构化的景区/游玩节点数量，不代表实际游玩时长或体验强弱。")
|
||
return "\n".join(lines), customer, evidence, plans
|
||
|
||
|
||
def _context_template_fallback_answer(question: str, graph_result: dict[str, Any]) -> tuple[str, str, list[dict[str, str]], list[dict[str, Any]]]:
|
||
products = _context_products_from_rows(graph_result)
|
||
products.sort(key=lambda item: (item.get("adult_price_min") is None, item.get("adult_price_min") or 999999, item.get("duration_days") or 99))
|
||
evidence: list[dict[str, str]] = []
|
||
plans: list[dict[str, Any]] = []
|
||
lines = ["已按线路实体查到以下可对比方案："]
|
||
for idx, product in enumerate(products[:6], start=1):
|
||
price = _money(product.get("adult_price_min"))
|
||
day_suffix = f"（{product['duration_days']}日）" if product.get("duration_days") else ""
|
||
price_text = f"，成人参考起价 {price}元/人" if price else "，价格需按团期核实"
|
||
line = f"{idx}. {product['product_name']}{day_suffix}{price_text}"
|
||
lines.append(line)
|
||
evidence.append({
|
||
"type": "线路对比证据",
|
||
"name": product["product_name"][:120],
|
||
"summary": line[:360],
|
||
"source": "FalkorDB 图查询 TourProduct/ProductPricePlan",
|
||
})
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "线路对比",
|
||
"plan_name": product["product_name"],
|
||
"product_name": product["product_name"],
|
||
"fit_score": max(60, 90 - idx * 3),
|
||
"match_reasons": ["命中线路实体", "读取报价和行程上下文"],
|
||
"route_summary": line,
|
||
"quote_summary": line,
|
||
"variant_summary": "",
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "deterministic_context_fallback",
|
||
})
|
||
if products:
|
||
best = products[0]
|
||
customer = f"从图谱报价看，预算优先可以先看 {best['product_name']}。如果有老人和小孩，还需要结合行程强度、住宿档位和出发日期确认，价格和余位需二次核实。"
|
||
else:
|
||
customer = "当前已进入线路对比查询，但图谱证据不足，建议补充具体线路、出发日期、人数和预算后再推荐。"
|
||
lines.append("建议最终按出发日期、人数、住宿档位、老人/儿童体力情况和供应商余位二次核实。")
|
||
return "\n".join(lines), customer, evidence, plans
|
||
|
||
|
||
async def _deterministic_context_response(
|
||
question: str,
|
||
graph_name: str,
|
||
*,
|
||
limit: int,
|
||
customer_context: dict[str, Any] | None,
|
||
started_at: float,
|
||
intent: dict[str, Any],
|
||
intent_ms: int,
|
||
) -> dict[str, Any] | None:
|
||
if intent.get("route") != "deterministic_context_llm_answer":
|
||
return None
|
||
if intent.get("intent") == "condition_route_advice":
|
||
cypher = _condition_context_cypher(limit)
|
||
else:
|
||
cypher = _route_context_cypher(question, limit) or ""
|
||
if not cypher:
|
||
return None
|
||
graph_started = time.perf_counter()
|
||
try:
|
||
graph_result = await asyncio.to_thread(_run_cypher, graph_name, cypher, limit)
|
||
except Exception:
|
||
return None
|
||
graph_ms = max(1, round((time.perf_counter() - graph_started) * 1000))
|
||
if not graph_result.get("row_count"):
|
||
return None
|
||
|
||
planner = intent.get("_planner_trace") if isinstance(intent.get("_planner_trace"), dict) else {}
|
||
planner_ms = _safe_int(planner.get("latency_ms"), 0)
|
||
answer_ms = 0
|
||
llm_error = ""
|
||
answer_data: dict[str, Any] = {}
|
||
answer_client = await _graph_qa_client(max_tokens=600)
|
||
if answer_client is not None:
|
||
payload = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"intent": intent,
|
||
"answer_focus": "基于线路报价、天数、景区数量和行程证据做 3 句话以内建议；证据不足必须说明需二次核实。",
|
||
"cypher": cypher,
|
||
"graph_result": {
|
||
"columns": graph_result["columns"],
|
||
"row_count": graph_result["row_count"],
|
||
"rows": graph_result["rows"][:6],
|
||
"nodes": [],
|
||
"relationships": [],
|
||
},
|
||
"customer_context": customer_context or {},
|
||
}
|
||
answer_started = time.perf_counter()
|
||
try:
|
||
answer_data = await _chat_json_timed(
|
||
answer_client,
|
||
GRAPH_QA_ANSWER_SYS,
|
||
json.dumps(payload, ensure_ascii=False),
|
||
timeout_seconds=GRAPH_QA_ANSWER_TIMEOUT_SECONDS,
|
||
attempts=1,
|
||
)
|
||
except asyncio.TimeoutError:
|
||
llm_error = "answer_timeout"
|
||
except Exception as exc: # noqa: BLE001
|
||
llm_error = str(exc)[:260]
|
||
answer_ms = max(1, round((time.perf_counter() - answer_started) * 1000))
|
||
|
||
if answer_data:
|
||
answer = str(answer_data.get("answer") or answer_data.get("customer_reply") or "").strip()
|
||
customer_reply = str(answer_data.get("customer_reply") or answer).strip()
|
||
evidence = _evidence_cards(answer_data, graph_result)
|
||
plans = _plans_from_evidence(evidence, answer)
|
||
confidence = _safe_confidence(answer_data.get("confidence"), 0.72)
|
||
followups = _list_texts(answer_data.get("follow_up_questions"), 4, 120)
|
||
risk_notes = _list_texts(answer_data.get("risk_notes"), 4, 160)
|
||
else:
|
||
answer, customer_reply, evidence, plans = _context_template_fallback_answer(question, graph_result)
|
||
confidence = 0.68
|
||
followups = ["请提供出发日期和人数。", "老人和小孩对行程强度有什么要求？", "预算范围和住宿档位是多少？"]
|
||
risk_notes = ["推荐仅基于图谱已有报价和线路信息，最终需按团期、余位和供应商政策二次核实。"]
|
||
|
||
latency_ms = max(1, round((time.perf_counter() - started_at) * 1000))
|
||
return {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"answer": answer,
|
||
"customer_reply": customer_reply,
|
||
"copy_text": customer_reply or answer,
|
||
"plans": plans,
|
||
"evidence": evidence,
|
||
"sales_scripts": [],
|
||
"follow_up_questions": followups,
|
||
"risk_notes": risk_notes,
|
||
"confidence": confidence,
|
||
"graph_result": graph_result,
|
||
"trace": {
|
||
"method": "deterministic_context_llm_answer_v1",
|
||
"query_source": "deterministic_context_cypher",
|
||
"rule_query_used": False,
|
||
"llm_used": bool(answer_data),
|
||
"llm_error": llm_error,
|
||
"cache_hit": False,
|
||
"cache": {"response": False, "cypher": False},
|
||
"generated_cypher": "",
|
||
"effective_cypher": cypher,
|
||
"cypher_cache_hit": False,
|
||
"fallback_cypher": "",
|
||
"fallback_query_used": False,
|
||
"cypher_reason": intent.get("reason") or "",
|
||
"intent": intent.get("intent") or "",
|
||
"llm_planner_used": bool(planner.get("used")),
|
||
"llm_planner": planner,
|
||
"graph_qa_intent": intent,
|
||
"routing_strategy": "intent_context_query_then_llm_answer",
|
||
"cypher_repaired": False,
|
||
"first_query_error": "",
|
||
"row_count": graph_result["row_count"],
|
||
"node_count": len(graph_result["nodes"]),
|
||
"relationship_count": len(graph_result["relationships"]),
|
||
"latency_ms": latency_ms,
|
||
"stage_timings_ms": {
|
||
"intent_classification": intent_ms,
|
||
"llm_planner": planner_ms,
|
||
"schema": 0,
|
||
"cypher_generation": 0,
|
||
"graph_query": graph_ms,
|
||
"fallback_graph_query": 0,
|
||
"answer_synthesis": answer_ms,
|
||
},
|
||
"performance_target_ms": 1200,
|
||
"response_mode": "deterministic_context_llm_answer",
|
||
"response_mode_label": "固定取证 + LLM 证据回答",
|
||
"graph_capabilities_used": ["意图识别", "固定 Cypher 取证", "LLM 证据回答"],
|
||
"retrieval_summary": {
|
||
"cypher": cypher,
|
||
"llm_generated_cypher": "",
|
||
"fallback_query_used": False,
|
||
"rows": graph_result["row_count"],
|
||
"nodes": len(graph_result["nodes"]),
|
||
"relationships": len(graph_result["relationships"]),
|
||
},
|
||
},
|
||
}
|
||
|
||
|
||
def _cache_key(question: str, graph_name: str, limit: int, customer_context: dict[str, Any] | None) -> str:
|
||
context_key = json.dumps(customer_context or {}, ensure_ascii=False, sort_keys=True, default=str)[:800]
|
||
normalized_question = re.sub(r"\s+", "", question.strip())
|
||
return f"{graph_name}|{limit}|{normalized_question}|{context_key}"
|
||
|
||
|
||
def _get_cached_response(cache_key: str, started_at: float) -> dict[str, Any] | None:
|
||
cached = _QA_RESPONSE_CACHE.get(cache_key)
|
||
if not cached:
|
||
return None
|
||
cached_at, payload = cached
|
||
if time.monotonic() - cached_at > QA_RESPONSE_CACHE_TTL_SECONDS:
|
||
_QA_RESPONSE_CACHE.pop(cache_key, None)
|
||
return None
|
||
response = copy.deepcopy(payload)
|
||
latency_ms = max(1, round((time.perf_counter() - started_at) * 1000))
|
||
trace = response.setdefault("trace", {})
|
||
trace["cache_hit"] = True
|
||
cache = trace.setdefault("cache", {})
|
||
cache["response"] = True
|
||
trace["latency_ms"] = latency_ms
|
||
trace["stage_timings_ms"] = {
|
||
**(trace.get("stage_timings_ms") or {}),
|
||
"cache_lookup": latency_ms,
|
||
}
|
||
return response
|
||
|
||
|
||
def _set_cached_response(cache_key: str, response: dict[str, Any]) -> None:
|
||
if len(_QA_RESPONSE_CACHE) > 256:
|
||
oldest_key = min(_QA_RESPONSE_CACHE, key=lambda key: _QA_RESPONSE_CACHE[key][0])
|
||
_QA_RESPONSE_CACHE.pop(oldest_key, None)
|
||
_QA_RESPONSE_CACHE[cache_key] = (time.monotonic(), copy.deepcopy(response))
|
||
|
||
|
||
def _cypher_cache_key(question: str, graph_name: str, limit: int, intent: dict[str, Any]) -> str:
|
||
normalized = _normalized_question(question)
|
||
return f"{graph_name}|{limit}|{intent.get('intent') or 'general'}|{normalized}"
|
||
|
||
|
||
def _get_cached_cypher(cache_key: str) -> dict[str, Any] | None:
|
||
cached = _CYPHER_CACHE.get(cache_key)
|
||
if not cached:
|
||
return None
|
||
cached_at, payload = cached
|
||
if time.monotonic() - cached_at > CYPHER_CACHE_TTL_SECONDS:
|
||
_CYPHER_CACHE.pop(cache_key, None)
|
||
return None
|
||
return copy.deepcopy(payload)
|
||
|
||
|
||
def _set_cached_cypher(cache_key: str, decision: dict[str, Any]) -> None:
|
||
if len(_CYPHER_CACHE) > 512:
|
||
oldest_key = min(_CYPHER_CACHE, key=lambda key: _CYPHER_CACHE[key][0])
|
||
_CYPHER_CACHE.pop(oldest_key, None)
|
||
_CYPHER_CACHE[cache_key] = (time.monotonic(), copy.deepcopy(decision))
|
||
|
||
|
||
async def _fast_graph_response(
|
||
question: str,
|
||
graph_name: str,
|
||
*,
|
||
limit: int,
|
||
customer_context: dict[str, Any] | None,
|
||
started_at: float,
|
||
intent: dict[str, Any],
|
||
intent_ms: int,
|
||
) -> dict[str, Any] | None:
|
||
if intent.get("route") != "template_graph_query":
|
||
return None
|
||
fast_kind = str(intent.get("intent") or "")
|
||
cypher = ""
|
||
if fast_kind == "route_catalog":
|
||
cypher = _route_catalog_cypher(limit)
|
||
elif fast_kind == "condition_route_advice":
|
||
cypher = _condition_context_cypher(limit)
|
||
elif fast_kind == "route_compare_suitability":
|
||
cypher = _route_context_cypher(question, limit) or ""
|
||
elif fast_kind == "route_compare_scenic_count":
|
||
cypher = _route_context_cypher(question, limit) or ""
|
||
elif fast_kind == "route_multihop_detail":
|
||
cypher = _route_multihop_cypher(question, limit) or ""
|
||
elif fast_kind == "price_quote":
|
||
cypher = _price_fallback_cypher(question, limit) or ""
|
||
elif fast_kind == "fee_detail":
|
||
cypher = _fee_fallback_cypher(question, limit) or ""
|
||
elif fast_kind == "vehicle_catalog":
|
||
cypher = _vehicle_catalog_cypher(limit)
|
||
if not cypher:
|
||
return None
|
||
|
||
graph_started = time.perf_counter()
|
||
try:
|
||
graph_result = await asyncio.to_thread(_run_cypher, graph_name, cypher, limit)
|
||
except Exception:
|
||
return None
|
||
graph_ms = max(1, round((time.perf_counter() - graph_started) * 1000))
|
||
if not graph_result.get("row_count"):
|
||
return None
|
||
|
||
planner = intent.get("_planner_trace") if isinstance(intent.get("_planner_trace"), dict) else {}
|
||
planner_ms = _safe_int(planner.get("latency_ms"), 0)
|
||
if fast_kind == "route_catalog":
|
||
route_answer = _route_list_answer(question, graph_result)
|
||
if not route_answer:
|
||
return None
|
||
answer, customer_reply = route_answer
|
||
items = _route_items_from_rows(graph_result)
|
||
evidence = [
|
||
{
|
||
"type": "线路清单",
|
||
"name": item["name"],
|
||
"summary": f"{item['name']}" + (f"（{item['duration_days']}日）" if item.get("duration_days") else ""),
|
||
"source": "FalkorDB 图查询 TourProduct",
|
||
}
|
||
for item in items[:12]
|
||
]
|
||
plans = [
|
||
{
|
||
"rank": idx,
|
||
"label": "线路清单",
|
||
"plan_name": item["name"],
|
||
"product_name": item["name"],
|
||
"fit_score": max(60, 95 - idx),
|
||
"match_reasons": ["线路清单快查", "读取 TourProduct"],
|
||
"route_summary": item["name"],
|
||
"quote_summary": "可继续按线路名称、日期和人数查询报价。",
|
||
"variant_summary": "",
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "fast_route_catalog",
|
||
}
|
||
for idx, item in enumerate(items[:4], start=1)
|
||
]
|
||
followups = ["要查哪条线路的价格？", "请提供出发日期、人数和住宿偏好。", "是否需要按天数或景点筛选线路？"]
|
||
confidence = 0.9
|
||
elif fast_kind == "condition_route_advice":
|
||
condition_answer = _condition_route_template_answer(question, graph_result)
|
||
if not condition_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = condition_answer
|
||
followups = ["请提供出发日期和人数。", "老人或小孩是否有少走路要求？", "预算和住宿档位大概是多少？"]
|
||
confidence = 0.78
|
||
elif fast_kind == "route_compare_suitability":
|
||
suitability_answer = _route_compare_suitability_answer(question, graph_result)
|
||
if not suitability_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = suitability_answer
|
||
followups = ["请提供出发日期和人数。", "老人小孩是否能接受爬山或较多步行？", "是否需要同时比较价格？"]
|
||
confidence = 0.8
|
||
elif fast_kind == "route_compare_scenic_count":
|
||
compare_answer = _route_compare_scenic_count_answer(question, graph_result)
|
||
if not compare_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = compare_answer
|
||
followups = ["是否还要比较价格和行程强度？", "请提供出发日期和人数。", "是否需要按老人/儿童适配度再筛选？"]
|
||
confidence = 0.82
|
||
elif fast_kind == "route_multihop_detail":
|
||
multihop_answer = _route_multihop_template_answer(question, graph_result)
|
||
if not multihop_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = multihop_answer
|
||
followups = ["请提供出发日期和人数。", "是否需要指定住宿档位或房型？", "要继续核实哪个景区附近酒店？"]
|
||
confidence = 0.88
|
||
elif fast_kind == "price_quote":
|
||
price_answer = _price_template_answer(question, graph_result)
|
||
if not price_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = price_answer
|
||
followups = ["请提供出发日期和人数。", "是否有住宿档位要求？", "是否需要同步查询儿童价和单房差？"]
|
||
confidence = 0.86
|
||
elif fast_kind == "fee_detail":
|
||
fee_answer = _fee_template_answer(question, graph_result)
|
||
if not fee_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = fee_answer
|
||
followups = ["要按哪一天或哪个景区核实费用？", "是否需要区分必含和自费项目？", "请提供出发日期方便核实景区政策。"]
|
||
confidence = 0.84
|
||
elif fast_kind == "vehicle_catalog":
|
||
vehicle_answer = _vehicle_template_answer(question, graph_result)
|
||
if not vehicle_answer:
|
||
return None
|
||
answer, customer_reply, evidence, plans = vehicle_answer
|
||
followups = ["请提供出发日期和人数。", "是否需要指定车型或座位布局？", "是否需要核算包车费用？"]
|
||
confidence = 0.82
|
||
else:
|
||
return None
|
||
|
||
latency_ms = max(1, round((time.perf_counter() - started_at) * 1000))
|
||
return {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"answer": answer,
|
||
"customer_reply": customer_reply,
|
||
"copy_text": customer_reply or answer,
|
||
"plans": plans,
|
||
"evidence": evidence,
|
||
"sales_scripts": [],
|
||
"follow_up_questions": followups,
|
||
"risk_notes": ["价格、余位、房型、车辆和景区政策以具体团期及供应商二次核实为准。"],
|
||
"confidence": confidence,
|
||
"graph_result": graph_result,
|
||
"trace": {
|
||
"method": f"fast_{fast_kind}_graph_template_v1",
|
||
"query_source": "deterministic_cypher_template",
|
||
"rule_query_used": False,
|
||
"llm_used": False,
|
||
"cache_hit": False,
|
||
"cache": {"response": False, "cypher": False},
|
||
"generated_cypher": "",
|
||
"effective_cypher": cypher,
|
||
"fallback_cypher": "",
|
||
"fallback_query_used": False,
|
||
"cypher_reason": "高频客服问题命中固定只读图查询模板，跳过 LLM 生成 Cypher 和 LLM 答案组织。",
|
||
"intent": fast_kind,
|
||
"llm_planner_used": bool(planner.get("used")),
|
||
"llm_planner": planner,
|
||
"graph_qa_intent": intent,
|
||
"routing_strategy": "intent_template_first",
|
||
"cypher_repaired": False,
|
||
"first_query_error": "",
|
||
"row_count": graph_result["row_count"],
|
||
"node_count": len(graph_result["nodes"]),
|
||
"relationship_count": len(graph_result["relationships"]),
|
||
"latency_ms": latency_ms,
|
||
"stage_timings_ms": {
|
||
"intent_classification": intent_ms,
|
||
"llm_planner": planner_ms,
|
||
"schema": 0,
|
||
"cypher_generation": 0,
|
||
"graph_query": graph_ms,
|
||
"fallback_graph_query": 0,
|
||
"answer_synthesis": 0,
|
||
},
|
||
"performance_target_ms": 1200,
|
||
"response_mode": "fast_graph_template",
|
||
"response_mode_label": "高频客服问题快查",
|
||
"graph_capabilities_used": ["固定 Cypher 模板", "FalkorDB 只读查询", "客服话术模板"],
|
||
"retrieval_summary": {
|
||
"cypher": cypher,
|
||
"llm_generated_cypher": "",
|
||
"fallback_query_used": False,
|
||
"rows": graph_result["row_count"],
|
||
"nodes": len(graph_result["nodes"]),
|
||
"relationships": len(graph_result["relationships"]),
|
||
},
|
||
},
|
||
}
|
||
|
||
|
||
def _evidence_cards(answer_data: dict[str, Any], graph_result: dict[str, Any]) -> list[dict[str, str]]:
|
||
cards: list[dict[str, str]] = []
|
||
raw_cards = answer_data.get("evidence_cards")
|
||
if isinstance(raw_cards, list):
|
||
for item in raw_cards[:6]:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
title = str(item.get("title") or item.get("name") or "").strip()
|
||
summary = str(item.get("summary") or item.get("detail") or "").strip()
|
||
source = str(item.get("source") or "FalkorDB 图查询").strip()
|
||
if title or summary:
|
||
cards.append({"type": "图查询证据", "name": title[:120], "summary": summary[:360], "source": source[:120]})
|
||
for node in (graph_result.get("nodes") or [])[:6]:
|
||
if len(cards) >= 8:
|
||
break
|
||
props = node.get("properties") or {}
|
||
summary = "；".join(
|
||
f"{k}: {v}" for k, v in list(props.items())[:6] if v not in (None, "")
|
||
)
|
||
cards.append({
|
||
"type": "图谱节点",
|
||
"name": str(node.get("title") or "")[:120],
|
||
"summary": summary[:360],
|
||
"source": "FalkorDB 图查询",
|
||
})
|
||
return cards
|
||
|
||
|
||
def _plans_from_evidence(cards: list[dict[str, str]], answer: str) -> list[dict[str, Any]]:
|
||
plans: list[dict[str, Any]] = []
|
||
for idx, card in enumerate(cards[:4], start=1):
|
||
plans.append({
|
||
"rank": idx,
|
||
"label": "图查询证据",
|
||
"plan_name": card.get("name") or f"图谱证据 {idx}",
|
||
"product_name": card.get("name") or "",
|
||
"fit_score": max(60, 92 - idx * 4),
|
||
"match_reasons": ["LLM 生成 Cypher 查询命中", "来自百姓惠知识图谱"],
|
||
"route_summary": card.get("summary") or answer[:240],
|
||
"quote_summary": answer[:360],
|
||
"variant_summary": card.get("summary") or "",
|
||
"daily_itinerary": [],
|
||
"hotels": [],
|
||
"restaurants": [],
|
||
"vehicles": [],
|
||
"policies": [],
|
||
"cost_breakdown": [],
|
||
"plan_kind": "llm_graph_evidence",
|
||
})
|
||
return plans
|
||
|
||
|
||
def _safe_confidence(value: Any, default: float = 0.72) -> float:
|
||
try:
|
||
return max(0.0, min(1.0, float(value)))
|
||
except Exception:
|
||
return default
|
||
|
||
|
||
async def answer_graph_question(
|
||
question: str,
|
||
graph_name: str,
|
||
*,
|
||
customer_context: dict[str, Any] | None = None,
|
||
limit: int = 80,
|
||
) -> dict[str, Any]:
|
||
started_at = time.perf_counter()
|
||
limit = min(max(int(limit or 80), 1), GRAPH_QA_MAX_LIMIT)
|
||
question = question.strip()
|
||
if not question:
|
||
raise ValueError("question required")
|
||
|
||
cache_key = _cache_key(question, graph_name, limit, customer_context)
|
||
cached_response = _get_cached_response(cache_key, started_at)
|
||
if cached_response:
|
||
return cached_response
|
||
|
||
intent_started = time.perf_counter()
|
||
rule_intent = _classify_graph_qa_intent(question)
|
||
intent, planner_trace = await _llm_plan_intent(question, graph_name, rule_intent, customer_context)
|
||
intent["_planner_trace"] = planner_trace
|
||
intent_ms = max(1, round((time.perf_counter() - intent_started) * 1000))
|
||
fast_response = await _fast_graph_response(
|
||
question,
|
||
graph_name,
|
||
limit=limit,
|
||
customer_context=customer_context,
|
||
started_at=started_at,
|
||
intent=intent,
|
||
intent_ms=intent_ms,
|
||
)
|
||
if fast_response:
|
||
_set_cached_response(cache_key, fast_response)
|
||
return fast_response
|
||
|
||
context_response = await _deterministic_context_response(
|
||
question,
|
||
graph_name,
|
||
limit=limit,
|
||
customer_context=customer_context,
|
||
started_at=started_at,
|
||
intent=intent,
|
||
intent_ms=intent_ms,
|
||
)
|
||
if context_response:
|
||
_set_cached_response(cache_key, context_response)
|
||
return context_response
|
||
|
||
cypher_cache_key = _cypher_cache_key(question, graph_name, limit, intent)
|
||
cached_decision = _get_cached_cypher(cypher_cache_key)
|
||
cypher_cache_hit = bool(cached_decision)
|
||
cypher_client: LlmClient | None = None
|
||
if cached_decision:
|
||
decision = cached_decision
|
||
schema_ms = 0
|
||
cypher_ms = 0
|
||
else:
|
||
cypher_client = await _graph_qa_client(max_tokens=1000, use_config_max_tokens=False)
|
||
if cypher_client is None:
|
||
raise RuntimeError("LLM 未配置，无法执行自然语言图查询")
|
||
cypher_client.timeout = min(float(getattr(cypher_client, "timeout", GRAPH_QA_CYPHER_TIMEOUT_SECONDS) or GRAPH_QA_CYPHER_TIMEOUT_SECONDS), GRAPH_QA_CYPHER_TIMEOUT_SECONDS)
|
||
schema_started = time.perf_counter()
|
||
schema = await asyncio.to_thread(_schema_snapshot, graph_name)
|
||
schema_ms = max(1, round((time.perf_counter() - schema_started) * 1000))
|
||
plan_payload = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"intent": intent,
|
||
"customer_context": customer_context or {},
|
||
"graph_schema": schema,
|
||
"default_limit": limit,
|
||
}
|
||
cypher_started = time.perf_counter()
|
||
decision = await _chat_json_timed(
|
||
cypher_client,
|
||
GRAPH_QA_CYPHER_SYS,
|
||
json.dumps(plan_payload, ensure_ascii=False),
|
||
timeout_seconds=GRAPH_QA_CYPHER_TIMEOUT_SECONDS,
|
||
attempts=1,
|
||
)
|
||
cypher_ms = max(1, round((time.perf_counter() - cypher_started) * 1000))
|
||
_set_cached_cypher(cypher_cache_key, decision)
|
||
|
||
answer_client = await _graph_qa_client(max_tokens=650)
|
||
if answer_client is None:
|
||
raise RuntimeError("LLM 未配置，无法执行自然语言图查询")
|
||
answer_client.timeout = min(float(getattr(answer_client, "timeout", GRAPH_QA_ANSWER_TIMEOUT_SECONDS) or GRAPH_QA_ANSWER_TIMEOUT_SECONDS), GRAPH_QA_ANSWER_TIMEOUT_SECONDS)
|
||
generated_cypher = _clean_cypher(decision.get("cypher"), limit)
|
||
llm_generated_cypher = generated_cypher
|
||
graph_result: dict[str, Any]
|
||
query_error = ""
|
||
repaired = False
|
||
fallback_used = False
|
||
fallback_cypher = ""
|
||
fallback_ms = 0
|
||
try:
|
||
graph_started = time.perf_counter()
|
||
graph_result = await asyncio.to_thread(_run_cypher, graph_name, generated_cypher, limit)
|
||
graph_ms = max(1, round((time.perf_counter() - graph_started) * 1000))
|
||
except Exception as exc: # noqa: BLE001
|
||
query_error = str(exc)[:400]
|
||
if cypher_client is None:
|
||
cypher_client = await _graph_qa_client(max_tokens=1000, use_config_max_tokens=False)
|
||
if cypher_client is None:
|
||
raise
|
||
cypher_client.timeout = min(float(getattr(cypher_client, "timeout", GRAPH_QA_REPAIR_TIMEOUT_SECONDS) or GRAPH_QA_REPAIR_TIMEOUT_SECONDS), GRAPH_QA_REPAIR_TIMEOUT_SECONDS)
|
||
repair_payload = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"intent": intent,
|
||
"customer_context": customer_context or {},
|
||
"failed_cypher": generated_cypher,
|
||
"execution_error": query_error,
|
||
}
|
||
repaired_decision = await _chat_json_timed(
|
||
cypher_client,
|
||
GRAPH_QA_REPAIR_SYS,
|
||
json.dumps(repair_payload, ensure_ascii=False),
|
||
timeout_seconds=GRAPH_QA_REPAIR_TIMEOUT_SECONDS,
|
||
attempts=1,
|
||
)
|
||
generated_cypher = _clean_cypher(repaired_decision.get("cypher"), limit)
|
||
decision = {**decision, **repaired_decision}
|
||
repaired = True
|
||
graph_started = time.perf_counter()
|
||
graph_result = await asyncio.to_thread(_run_cypher, graph_name, generated_cypher, limit)
|
||
graph_ms = max(1, round((time.perf_counter() - graph_started) * 1000))
|
||
|
||
if _is_fee_question(question) and not _has_fee_evidence(graph_result):
|
||
fallback_cypher = _fee_fallback_cypher(question, limit) or ""
|
||
if fallback_cypher:
|
||
try:
|
||
fallback_started = time.perf_counter()
|
||
fallback_result = await asyncio.to_thread(_run_cypher, graph_name, fallback_cypher, limit)
|
||
fallback_ms = max(1, round((time.perf_counter() - fallback_started) * 1000))
|
||
if fallback_result.get("row_count") and _has_fee_evidence(fallback_result):
|
||
graph_result = fallback_result
|
||
generated_cypher = fallback_cypher
|
||
fallback_used = True
|
||
except Exception as exc: # noqa: BLE001
|
||
query_error = "; ".join(item for item in [query_error, f"fallback: {str(exc)[:220]}"] if item)
|
||
|
||
if not graph_result.get("row_count"):
|
||
latency_ms = max(1, round((time.perf_counter() - started_at) * 1000))
|
||
planner = intent.get("_planner_trace") if isinstance(intent.get("_planner_trace"), dict) else {}
|
||
planner_ms = _safe_int(planner.get("latency_ms"), 0)
|
||
answer = "已完成 LLM 图查询，但当前图谱没有命中可确认数据。建议补充更具体的线路、景区、套餐名称、出发日期或人数后再查。"
|
||
customer_reply = "抱歉，当前图谱暂未查到相关产品或套餐。您可以补充具体线路、景区、出发日期或套餐名称，我再帮您核实。"
|
||
response = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"answer": answer,
|
||
"customer_reply": customer_reply,
|
||
"copy_text": customer_reply,
|
||
"plans": [],
|
||
"evidence": [],
|
||
"sales_scripts": [],
|
||
"follow_up_questions": ["请补充具体线路/产品名称。", "请说明出发日期、人数或套餐名称。", "是否要改查百姓惠旅游线路、价格、景区或酒店？"],
|
||
"risk_notes": ["图谱查询结果为空，不代表业务一定不存在，需按产品库或人工渠道二次核实。"],
|
||
"confidence": 0.28,
|
||
"graph_result": graph_result,
|
||
"trace": {
|
||
"method": "llm_to_cypher_graph_qa_v1",
|
||
"query_source": "llm_generated_cypher",
|
||
"rule_query_used": False,
|
||
"llm_used": True,
|
||
"llm_error": "",
|
||
"generated_cypher": llm_generated_cypher,
|
||
"effective_cypher": generated_cypher,
|
||
"cache": {"response": False, "cypher": cypher_cache_hit},
|
||
"cypher_cache_hit": cypher_cache_hit,
|
||
"fallback_cypher": fallback_cypher,
|
||
"fallback_query_used": fallback_used,
|
||
"cypher_reason": decision.get("reason") or "",
|
||
"intent": intent.get("intent") or "",
|
||
"llm_planner_used": bool(planner.get("used")),
|
||
"llm_planner": planner,
|
||
"graph_qa_intent": intent,
|
||
"routing_strategy": "intent_template_first_llm_fallback",
|
||
"cypher_repaired": repaired,
|
||
"first_query_error": query_error,
|
||
"row_count": 0,
|
||
"node_count": 0,
|
||
"relationship_count": 0,
|
||
"latency_ms": latency_ms,
|
||
"stage_timings_ms": {
|
||
"intent_classification": intent_ms,
|
||
"llm_planner": planner_ms,
|
||
"schema": schema_ms,
|
||
"cypher_generation": cypher_ms,
|
||
"graph_query": graph_ms,
|
||
"fallback_graph_query": fallback_ms,
|
||
"answer_synthesis": 0,
|
||
},
|
||
"performance_target_ms": 1200,
|
||
"response_mode": "llm_graph_qa",
|
||
"response_mode_label": "LLM 图查询问答",
|
||
"graph_capabilities_used": ["LLM-to-Cypher", "FalkorDB 只读查询", "空结果快速返回"],
|
||
"retrieval_summary": {
|
||
"cypher": generated_cypher,
|
||
"llm_generated_cypher": llm_generated_cypher,
|
||
"fallback_query_used": fallback_used,
|
||
"rows": 0,
|
||
"nodes": 0,
|
||
"relationships": 0,
|
||
},
|
||
},
|
||
}
|
||
_set_cached_response(cache_key, response)
|
||
return response
|
||
|
||
answer_payload = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"intent": intent,
|
||
"answer_focus": decision.get("answer_focus") or "",
|
||
"cypher": generated_cypher,
|
||
"graph_result": {
|
||
"columns": graph_result["columns"],
|
||
"row_count": graph_result["row_count"],
|
||
"rows": graph_result["rows"][:8],
|
||
"nodes": graph_result["nodes"][:10],
|
||
"relationships": graph_result["relationships"][:10],
|
||
},
|
||
"customer_context": customer_context or {},
|
||
}
|
||
answer_started = time.perf_counter()
|
||
answer_error = ""
|
||
try:
|
||
answer_data = await _chat_json_timed(
|
||
answer_client,
|
||
GRAPH_QA_ANSWER_SYS,
|
||
json.dumps(answer_payload, ensure_ascii=False),
|
||
timeout_seconds=GRAPH_QA_ANSWER_TIMEOUT_SECONDS,
|
||
attempts=1,
|
||
)
|
||
except asyncio.TimeoutError:
|
||
answer_data = {}
|
||
answer_error = "answer_timeout"
|
||
except Exception as exc: # noqa: BLE001
|
||
answer_data = {}
|
||
answer_error = str(exc)[:260]
|
||
answer_ms = max(1, round((time.perf_counter() - answer_started) * 1000))
|
||
answer = str(answer_data.get("answer") or answer_data.get("customer_reply") or "").strip()
|
||
route_list_override = _route_list_answer(question, graph_result)
|
||
if route_list_override:
|
||
answer, customer_reply_override = route_list_override
|
||
answer_data["customer_reply"] = customer_reply_override
|
||
answer_data.setdefault("follow_up_questions", ["要查哪条线路的价格？", "请提供出发日期和人数。"])
|
||
answer_data.setdefault("risk_notes", ["价格、余位和用车需按具体团期二次核实。"])
|
||
if not answer:
|
||
answer = "图查询已完成，但答案组织 LLM 未在时间预算内返回。为避免编造，建议查看返回的 knowledge.evidence，并补充更明确的景点、线路、团期、人数或费用口径。"
|
||
customer_reply = str(answer_data.get("customer_reply") or answer).strip()
|
||
evidence = _evidence_cards(answer_data, graph_result)
|
||
plans = _plans_from_evidence(evidence, answer)
|
||
latency_ms = max(1, round((time.perf_counter() - started_at) * 1000))
|
||
planner = intent.get("_planner_trace") if isinstance(intent.get("_planner_trace"), dict) else {}
|
||
planner_ms = _safe_int(planner.get("latency_ms"), 0)
|
||
response = {
|
||
"question": question,
|
||
"graph_name": graph_name,
|
||
"answer": answer,
|
||
"customer_reply": customer_reply,
|
||
"copy_text": customer_reply or answer,
|
||
"plans": plans,
|
||
"evidence": evidence,
|
||
"sales_scripts": [],
|
||
"follow_up_questions": _list_texts(answer_data.get("follow_up_questions"), 4, 120),
|
||
"risk_notes": _list_texts(answer_data.get("risk_notes"), 4, 160),
|
||
"confidence": _safe_confidence(answer_data.get("confidence")),
|
||
"graph_result": graph_result,
|
||
"trace": {
|
||
"method": "llm_to_cypher_graph_qa_v1",
|
||
"query_source": "llm_generated_cypher",
|
||
"rule_query_used": False,
|
||
"llm_used": True,
|
||
"llm_error": answer_error,
|
||
"generated_cypher": llm_generated_cypher,
|
||
"effective_cypher": generated_cypher,
|
||
"cache": {"response": False, "cypher": cypher_cache_hit},
|
||
"cypher_cache_hit": cypher_cache_hit,
|
||
"fallback_cypher": fallback_cypher,
|
||
"fallback_query_used": fallback_used,
|
||
"cypher_reason": decision.get("reason") or "",
|
||
"intent": intent.get("intent") or "",
|
||
"llm_planner_used": bool(planner.get("used")),
|
||
"llm_planner": planner,
|
||
"graph_qa_intent": intent,
|
||
"routing_strategy": "intent_template_first_llm_fallback",
|
||
"cypher_repaired": repaired,
|
||
"first_query_error": query_error,
|
||
"row_count": graph_result["row_count"],
|
||
"node_count": len(graph_result["nodes"]),
|
||
"relationship_count": len(graph_result["relationships"]),
|
||
"latency_ms": latency_ms,
|
||
"stage_timings_ms": {
|
||
"intent_classification": intent_ms,
|
||
"llm_planner": planner_ms,
|
||
"schema": schema_ms,
|
||
"cypher_generation": cypher_ms,
|
||
"graph_query": graph_ms,
|
||
"fallback_graph_query": fallback_ms,
|
||
"answer_synthesis": answer_ms,
|
||
},
|
||
"performance_target_ms": 1200,
|
||
"response_mode": "llm_graph_qa",
|
||
"response_mode_label": "LLM 图查询问答",
|
||
"graph_capabilities_used": ["LLM-to-Cypher", "FalkorDB 只读查询", "LLM evidence synthesis"],
|
||
"retrieval_summary": {
|
||
"cypher": generated_cypher,
|
||
"llm_generated_cypher": llm_generated_cypher,
|
||
"fallback_query_used": fallback_used,
|
||
"rows": graph_result["row_count"],
|
||
"nodes": len(graph_result["nodes"]),
|
||
"relationships": len(graph_result["relationships"]),
|
||
},
|
||
},
|
||
}
|
||
_set_cached_response(cache_key, response)
|
||
return response
|