当Lex无法匹配用户查询意图时，如何调用Lambda实现意图建议与数据存储？

Alright, let's walk through how to make this work for your Lex bot. I've tackled similar setups before, so here's a step-by-step breakdown that covers all your requirements:

1. Configure Lex to Trigger Lambda on Unmatched Queries #

First, you’ll need to use Lex’s Fallback Intent—this is exactly designed for when user input doesn’t match any of your existing 4 intents. Here’s how to set it up:

• In the Lex console, go to your bot’s settings and enable the Fallback Intent.
• Associate your custom Lambda function with this intent. This ensures every unrecognized query gets routed straight to your Lambda for processing.

2. Build the Lambda Function Core Logic #

Your Lambda needs two key jobs: suggest relevant intents via topic modeling, and store the unrecognized query for future analysis. Let’s break this down with a practical Python example:

a. Intent Suggestion with Topic Modeling #

Assuming you’ve pre-trained a topic modeling model (like BERTopic or LDA) mapped to your 4 intents, load it into Lambda (you can store the trained model in S3 for easy access). The model will analyze the user’s query and map it to the closest intent.

b. Store Queries in S3/RDB #

Choose between S3 (great for bulk, unstructured data) or a serverless RDB like DynamoDB (ideal for queryable, structured records). Include metadata like timestamp, user ID, and suggested intent for later analysis.

Here’s a simplified Lambda code snippet:

import boto3
import json
from datetime import datetime
from bertopic import BERTopic  # Use your preferred topic modeling library

# Initialize clients
s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')
query_table = dynamodb.Table('UnmatchedLexQueries')

# Load pre-trained topic model from S3
topic_model = BERTopic.load("s3://your-model-bucket/lex-intent-topic-model")
# Map model topics to your 4 existing intents
topic_to_intent = {
    0: "BillingSupportIntent",
    1: "AccountSetupIntent",
    2: "TechnicalIssueIntent",
    3: "ProductInfoIntent"
}

def lambda_handler(event, context):
    user_query = event['inputTranscript']
    user_id = event.get('userId', 'anonymous')

    # Run topic modeling to suggest an intent
    topics, _ = topic_model.transform([user_query])
    suggested_intent = topic_to_intent.get(topics[0], "a related topic")

    # Craft the user response
    lex_response = {
        "sessionState": {
            "dialogAction": {
                "type": "ElicitIntent",
                "message": {
                    "contentType": "PlainText",
                    "content": f"Sorry, I didn't catch that. It looks like your question might relate to *{suggested_intent}*—could you rephrase or ask about that specifically?"
                }
            }
        }
    }

    # Store query in DynamoDB
    query_table.put_item(
        Item={
            'query_id': context.aws_request_id,
            'query_text': user_query,
            'timestamp': datetime.utcnow().isoformat(),
            'user_id': user_id,
            'suggested_intent': suggested_intent
        }
    )

    # Optional: Store raw query in S3 for bulk analysis
    s3.put_object(
        Bucket='lex-unmatched-queries',
        Key=f"daily-queries/{datetime.utcnow().strftime('%Y-%m-%d')}/{context.aws_request_id}.json",
        Body=json.dumps({"query": user_query, "suggested_intent": suggested_intent})
    )

    return lex_response

3. Automate Intent Addition for Repeated Queries #

To turn frequent unrecognized queries into new Lex intents, set up an automated pipeline:

• Use CloudWatch Events to trigger a second Lambda or Glue Job daily (or hourly, based on volume).
• This job will scan your stored queries, count repeat occurrences (or cluster similar queries using the same topic model), and flag queries that meet your threshold (e.g., 5+ repeats).
• Use Lex’s CreateIntent API to auto-add new intents with the repeated queries as sample utterances.

Here’s a quick snippet for the auto-intent creation:

lexv2 = boto3.client('lexv2-models')

def create_lex_intent(intent_name, sample_utterances):
    response = lexv2.create_intent(
        intentName=intent_name,
        description=f"Auto-created intent for frequent query: {sample_utterances[0]}",
        sampleUtterances=[{"utterance": utt} for utt in sample_utterances],
        botId='your-bot-id',
        botVersion='DRAFT',
        localeId='en_US'
    )
    return response

4. Key Best Practices #

• Model Retraining: Schedule monthly retraining of your topic model with new stored queries to improve intent suggestion accuracy.
• Compliance: Anonymize user data if needed to meet privacy regulations (GDPR/CCPA).
• Threshold Tuning: Start with a higher repeat threshold (like 10) to avoid cluttering your bot with low-value intents, then adjust based on usage.

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