Skip to main content
In this lesson we’ll show a pragmatic integration pattern that combines Amazon Lex (for deterministic, structured dialogue management) with Amazon Bedrock (for generative, open-ended responses). The hybrid approach gives you the best of both worlds: reliable slot collection and turn-taking from Lex, and creative, contextual responses from Bedrock—glued together with AWS Lambda as the orchestration and safety layer.
An infographic asking "How can we build conversational applications that combine structure with AI-generated responses?" showing Amazon Lex as suited for structured conversations and Amazon Bedrock for more dynamic, generative responses.

​
The problem: conversational logic is complex

Building a production-grade conversational application—such as a travel-booking assistant—requires more than simple question-and-answer behavior. You need:
  • Deterministic slot collection (departure, destination, dates, passengers, etc.)
  • Validation and turn management (prompting for missing information)
  • Backend integrations (booking APIs, availability checks)
  • Handling of open-ended user requests that don’t fit a rigid intent model (e.g., “I have a five-hour layover in London; what should I visit?”)
Rule-driven systems (Amazon Lex) are excellent for the structured parts: intents, slots, and predictable dialog flows. Foundation models (via Amazon Bedrock) shine at handling vague, creative, or multi-step planning requests. Each approach has trade-offs—combine them and you can keep control where you need it while offering flexible, human-like responses where it matters.
A slide titled "Problem: Building Conversational Logic From Scratch Is Complex!" showing two components: Amazon Lex (handles conversation flow and slot collection like budget and preferences) and Amazon Bedrock (handles interpreting vague intent, generating recommendations, and personalized responses).

​
Why combine Lex + Bedrock?

  • Amazon Lex
    • Managed conversational interface
    • Intent recognition, slot prompting, and validation
    • Turn management for multi-step dialogs
    • Built-in text and voice channels
    • Deterministic, rule-driven flows for predictable UX
  • Amazon Bedrock
    • Access to foundation models for generative capabilities
    • Natural-language generation for summarization, recommendations, and personalization
    • Flexible interpretation of vague or creative requests
    • Prompt-based control and system messages to guide model output
Combining Lex with Bedrock lets you keep structured interactions under Lex’s control, and delegate open-ended or personalized responses to Bedrock when appropriate.
A presentation slide titled "Solution: Use Amazon Lex With Bedrock" that compares two columns: Amazon Lex (manages conversation flow, uses intents and slots, rule‑driven, structured dialogue) and Amazon Bedrock (generates AI responses, uses foundation models, probabilistic text generation, generative output).

​
Integration workflow (pattern)

A common, production-ready pattern is:
  1. User interacts via web, mobile, or voice.
  2. The application forwards user input to Amazon Lex.
  3. Lex does intent detection and slot collection:
    • If slots are missing for a known intent, Lex prompts the user to collect them.
    • If the input is open-ended or out-of-scope for configured intents, Lex invokes an AWS Lambda function.
  4. Lambda implements business logic:
    • Sanitize and validate the incoming text
    • Enforce authorization, rate limits, and policy checks
    • Build a contextual prompt (system messages + user query)
    • Call Amazon Bedrock Runtime (via AWS SDK) to run a chosen foundation model
    • Post-process the model output (formatting, truncation, safety filters)
  5. Lambda returns the formatted response to Lex, which continues the dialog and responds to the user.
This keeps turn-taking and slot management deterministic in Lex while outsourcing creative or summarization tasks to Bedrock.
A diagram titled "Solution: Use Amazon Lex With Bedrock" showing Amazon Lex plus Amazon Lambda on the left connected by an arrow to Amazon Bedrock on the right. It illustrates an integration flow from Lex and Lambda into Bedrock.

​
Who does what?

A slide titled "Workflow: Who Does What?" showing a vertical flow from a User (web/mobile/voice) through Amazon Lex, Amazon Lambda, Amazon Bedrock and back to Lambda. Each component has brief responsibilities listed (e.g., intent recognition and slot filling for Lex, business logic and API call for Lambda, foundation model response for Bedrock).

​
Example: travel assistant

  • Standard flows (search hotels, book flights, check status): Lex handles intent mapping, slot prompting, and backend API calls directly.
  • Open-ended flows (e.g., “What can I do during a five-hour layover in London?” or “Summarize my top 20 destinations into a top 5”): Lex routes to Lambda; Lambda composes a prompt with context and user constraints and calls Bedrock to generate recommendations or summaries; Lambda formats and returns the response to Lex.
This hybrid approach shortens time to market—build the core structured intents in Lex, and selectively add generative features with Bedrock where they improve the user experience.
A presentation slide titled "Workflow: Example Travel Conversational App" listing three numbered points: "Managed in Lex," "Connects to many different backends," and "No GenAI needed." To the right is a smartphone mockup showing a hotel booking interface with search fields and hotel cards.

​
Results and benefits

Using Lex + Lambda + Bedrock together gives you:
  1. Faster development: focus Lex on reliable, structured experiences and add generative capabilities incrementally.
  2. Reliable conversations: deterministic slot collection and intent validation remain under Lex’s control.
  3. Improved user experience: personalized recommendations, summaries, and natural-language responses from foundation models.
  4. Flexibility: handle both structured and open-ended queries within a single conversational system.
A dark-themed slide titled "Results: Faster Development and More Reliable Conversations" listing four numbered benefits for conversational applications (build smarter apps; combine reliability with flexibility; improve user experience; handle structured and open-ended queries), with a purple building icon on the right.

​
Operational and design considerations

  • Latency and cost: Bedrock calls introduce additional latency and cost versus pure Lex flows. Call Bedrock selectively—only for intents that need generative output.
  • Prompt engineering and context: construct prompts in Lambda that include relevant context, constraints (tone, length), and grounding information to improve model reliability.
  • Safety and compliance: implement filtering, redaction, and policy checks in Lambda before storing or forwarding user data. Consider PII handling and retention policies.
  • Model selection and testing: choose foundation models based on task (summarization, reasoning, creative generation) and validate outputs with test cases.
Be deliberate about when you call Bedrock. Excessive or unnecessary model calls increase latency and cost. Use conditional routing in Lex/Lambda so only relevant queries trigger generative AI.
Design Lambda as the policy and safety gate: sanitize inputs, add system-level context, enforce business rules, and post-process model outputs to maintain control and compliance.

​
Key takeaway

Amazon Lex provides predictable, managed dialog flows for structured interactions. When combined with AWS Lambda calling Amazon Bedrock, you can enrich those dialogs with generative, context-aware responses for open-ended tasks. Use Lex for control and Bedrock for creative or summarization capabilities—managed centrally by Lambda to ensure safety, compliance, and consistency.

​
Quick references

​
What’s next

This lesson described the Lex + Lambda + Bedrock integration pattern. A hands-on lab follows—build an AI-powered marketing email generator that implements the Lambda → Bedrock flow and demonstrates prompt construction, output formatting, and safety checks.

Watch Video