我之前在构建类似AI运维助手时碰到过几乎一模一样的问题——完全依赖LLM做意图检测在生产环境确实踩了不少坑。结合你的技术栈（Python/FastAPI/Groq/Redis），分享一些经过验证的生产级实践，帮你解决意图误判、参数缺失这些核心问题：

纯LLM的意图检测在模糊、口语化输入下的不确定性，根本无法满足生产环境对稳定性的要求。规则+LLM的混合架构是平衡灵活性与可靠性的最优解，再配合状态机管理会话参数，就能彻底解决你遇到的问题。

一、规则+LLM的分层意图检测 #

把意图检测分成两层，先过滤确定性场景，再让LLM处理复杂情况：

• 前置规则拦截：用简单的正则或关键词匹配处理明确/模糊的高频输入：
  • 比如用户单独输入approve/reassign，直接触发澄清逻辑，不用交给LLM猜意图；
  • 用re.search(r'(high|medium|low)\s*priority', user_input.lower())快速识别优先级调整意图，避免LLM误分到查询函数。
    规则的优势是100%确定性，能覆盖80%的高频简单场景，减少LLM的调用压力和误判概率。
• LLM做兜底处理：对于规则匹配不到的复杂输入（比如“帮我把昨天提交的那个工单改成高优先级并审批”），再交给LLM做意图分类和参数提取。同时给LLM的提示词里加上规则匹配的结果作为上下文，进一步约束模型的判断范围。

二、模糊输入与指代性输入的针对性处理 #

针对“approve”这类模糊输入 #

• 直接用前置规则拦截：只要用户输入是单独的操作动词，立刻触发澄清流程（比如“你需要审批哪个工单？请提供issue_id或工单名称”），完全跳过LLM的意图猜测环节。
• 补充会话上下文校验：如果会话历史里有最近操作的issue_id，可以主动询问用户“是否要审批最近操作的工单ID:XXX？”，减少用户输入成本。

针对“it”“that one”这类指代性输入 #

• 结构化存储会话状态：用Redis存储每个会话的核心上下文，比如最近操作的issue_id、当前未完成的参数收集任务。当用户输入指代性内容时，先从Redis读取最近的实体，再结合当前意图处理。
• 强制LLM结合上下文：在提示词里明确要求模型先检查会话历史中的实体，比如：“如果用户输入包含‘it’‘that’等指代词，请优先从会话历史中提取最近的issue_id作为参数，无法提取时再发起澄清”。

三、用状态机+Redis替代LLM内存做参数收集 #

LLM的上下文记忆根本不可靠，尤其是多轮对话时很容易丢失参数。用状态机+Redis管理参数收集流程，能确保参数100%齐全后再调用函数：

• 定义每个意图的参数收集状态：比如update_priority的状态可以是waiting_for_issue_id→waiting_for_priority→ready_to_call；
• 用Redis存储会话的当前状态和已收集的参数：比如用户输入“make it high priority”，如果Redis里没有最近的issue_id，就把状态设为waiting_for_issue_id，返回“请提供要调整优先级的工单ID”；用户提供后，更新状态为ready_to_call，自动调用后端函数；
• 参数校验前置：在调用后端函数前，先检查状态机里的参数是否齐全，不全的话直接触发澄清，完全避免因参数缺失导致的函数调用失败。

四、强化LLM提示词的约束性 #

即使使用混合方案，LLM的提示词也需要做针对性优化，减少模型的自由发挥：

• 明确给出意图列表和参数要求，比如：

  你只能从以下意图中选择：approve_completion（需参数issue_id）、update_priority（需参数issue_id、priority，可选值HIGH/MEDIUM/LOW）、query_function、clarify
  如果输入模糊无法确定意图，或参数缺失，请直接返回澄清问题，绝对不要猜测。

• 强制LLM输出结构化结果：要求模型返回JSON格式，包含intent、parameters、needs_clarification字段，方便后端解析和校验；
• 用结构化摘要替代原始会话历史：把Redis里的会话状态（比如“最近操作的工单ID:123”）作为上下文传给LLM，减少模型处理冗余信息的负担，提升参数提取的准确性。

五、落地示例（结合你的技术栈） #

这里给一个简化的FastAPI实现片段，展示规则+LLM+Redis状态机的协作逻辑：

from fastapi import FastAPI
import redis
import re
from groq import Groq

app = FastAPI()
# 初始化Redis客户端
r = redis.Redis(host='localhost', port=6379, db=0)
groq_client = Groq(api_key="your_groq_api_key")

# 前置规则匹配函数
def match_rule(user_input: str, session_id: str):
    user_input_lower = user_input.lower()
    # 处理单独的操作动词
    if user_input_lower in ["approve", "reassign"]:
        return {"intent": "clarify", "message": "请提供要操作的工单ID"}
    # 处理优先级调整
    priority_match = re.search(r'(high|medium|low)\s*priority', user_input_lower)
    if priority_match:
        priority = priority_match.group(1).upper()
        # 从Redis读取最近的issue_id
        last_issue_id = r.get(f"{session_id}:last_issue_id")
        if last_issue_id:
            return {
                "intent": "update_priority",
                "parameters": {"issue_id": last_issue_id.decode(), "priority": priority}
            }
        else:
            return {"intent": "clarify", "message": f"请提供要设置为{priority}优先级的工单ID"}
    return None

# LLM意图处理函数
def process_with_llm(user_input: str, session_summary: str):
    prompt = f"""
    会话摘要：{session_summary}
    用户输入：{user_input}
    请严格按照要求识别意图并提取参数，只能选择以下意图：approve_completion、update_priority、query_function、clarify
    输出格式必须为JSON：{{"intent": "...", "parameters": {{...}}, "message": "..."}}
    如果参数缺失或意图不明确，返回clarify并给出具体的澄清问题。
    """
    response = groq_client.chat.completions.create(
        model="llama3-70b-8192",
        messages=[{"role": "user", "content": prompt}]
    )
    return eval(response.choices[0].message.content)

@app.post("/handle_user_input")
async def handle_input(session_id: str, user_input: str):
    # 1. 先尝试规则匹配
    rule_result = match_rule(user_input, session_id)
    if rule_result:
        if rule_result["intent"] == "clarify":
            return rule_result
        # 规则匹配到有效意图，调用后端函数
        if rule_result["intent"] == "update_priority":
            # 这里调用你的update_priority函数
            # update_priority(**rule_result["parameters"])
            # 更新Redis中的最近工单ID
            r.set(f"{session_id}:last_issue_id", rule_result["parameters"]["issue_id"])
            return {"status": "success", "message": f"已将工单{rule_result['parameters']['issue_id']}优先级设置为{rule_result['parameters']['priority']}"}
    
    # 2. 规则匹配失败，用LLM处理
    session_summary = r.get(f"{session_id}:summary") or b""
    llm_result = process_with_llm(user_input, session_summary.decode())
    
    # 3. 处理LLM结果
    if llm_result["intent"] == "clarify":
        return llm_result
    else:
        # 参数校验：如果缺失issue_id，尝试从Redis读取最近值
        if "issue_id" not in llm_result["parameters"]:
            last_issue_id = r.get(f"{session_id}:last_issue_id")
            if last_issue_id:
                llm_result["parameters"]["issue_id"] = last_issue_id.decode()
            else:
                return {"intent": "clarify", "message": "请提供要操作的工单ID"}
        # 调用后端函数
        # 比如approve_completion(llm_result["parameters"]["issue_id"])
        r.set(f"{session_id}:last_issue_id", llm_result["parameters"]["issue_id"])
        # 更新会话摘要
        r.set(f"{session_id}:summary", f"最近操作工单ID:{llm_result['parameters']['issue_id']}")
        return {"status": "success", "message": f"已成功执行{llm_result['intent']}操作"}

通过这套方案，你能实现意图检测确定性强、参数收集可靠、函数调用零失败的生产级AI运维助手。

内容的提问来源于stack exchange，提问作者Ismail Is