Building Real-Time Travel Recommendation Systems with Amazon Bedrock and OpenSearch

Introduction

Planning travel isn’t just about destinations, it’s about personalization. Whether you’re recommending a romantic getaway or a family-friendly adventure, modern users expect their travel suggestions to match their unique preferences in real time.

This blog will show you how to build a real-time travel recommendation system using Amazon Bedrock, Amazon Bedrock Agents, Knowledge Bases, and Amazon OpenSearch Serverless. This setup allows you to combine static user preferences with live travel data (like flight prices) and personalized content generation using LLMs in a serverless, scalable AWS architecture.

Implementation Overview

AWS offers a powerful architecture that blends retrieval-augmented generation (RAG) with real-time orchestration. Here’s how it works:

1. User Input: The user provides preferences (budget, date, destination type).
2. Amazon DynamoDB Lookup: Their profile and history are fetched.
3. Amazon OpenSearch Query via Knowledge Base: Travel package data is searched semantically.
4. Live Flight Data Fetch: Amazon Bedrock Agent triggers AWS Lambda for real-time pricing.
5. LLM Response Generation: Amazon Bedrock uses the combined data to generate a personalized holiday recommendation.

Why Real-Time Recommendations Matter?

Traditional travel recommendation engines often rely on preloaded static content. While helpful, this approach quickly falls short because:

• Flight and hotel prices fluctuate every hour.
• Travel interests evolve during conversations (users may change budget, dates, or type of trip).
• Static search engines match keywords but often miss the context (e.g., “beach vacation” could return generic results without knowing whether the traveler wants luxury or budget-friendly stays).

By combining Retrieval-Augmented Generation (RAG) with real-time orchestration using Amazon Bedrock, businesses can solve these challenges:

• Personalized journeys: Recommendations are unique for every user.
• Contextual grounding: LLMs leverage curated travel data from your sources, not just generic information.
• Live updates: Flight pricing and availability are fetched dynamically.
• Scalable architecture: Serverless services scale traffic, making it cost-efficient.

Key Points

• Session-based chat: Each time a user clicks the chat icon, a unique session_id is generated and tracked in DynamoDB.
• Personalization: Preferences are fetched from Amazon DynamoDB to tailor the response.
• Retrieval-Augmented Generation (RAG): Amazon Bedrock Knowledge Base uses OpenSearch Serverless to ground LLM responses in curated travel data.
• Action group with AWS Lambda: Fetches real-time (mock) flight pricing based on the user query.
• RESTful APIs: Fully integrated with Amazon API Gateway for frontend access.
• Scalable & Serverless: No Amazon EC2 or containers; everything runs on AWS Lambda, Amazon API Gateway, Amazon Bedrock, Amazon DynamoDB, and Amazon OpenSearch.

Step-by-Step Guide

Step 1: Store Travel Data in Amazon S3

• Upload your curated travel packages (.json, .csv, etc.) into an Amazon S3 bucket.
• Include data like location, duration, theme, amenities, price, and accessibility features.

Step 2: Create an Amazon Bedrock Knowledge Base with OpenSearch

• When creating your Knowledge Base, choose Amazon OpenSearch Serverless as the vector store.
• Amazon Bedrock will:
  • Ingest data from Amazon S3.
  • Use an embedding model to convert it into vectors.
  • Store them in Amazon OpenSearch for similarity search.

Step 3: Set up Amazon DynamoDB for User Profiles

• Table: UserPreferences
• Sample record:

Step 4: Create an AWS Lambda for Real-Time Flight Pricing

• Lambda: FlightPriceFetcher
• Input: destination, dates
• Output: Real-time price and availability (can be a mocked API)

Step 5: Define Amazon Bedrock Agent and Actions

• Create an Amazon Bedrock Agent.
• Add an Action Group to invoke the FlightPriceFetcher Lambda.
• Define the schema for input/output so the agent can pass the correct parameters.

Step 6: Write Orchestrator Lambda

This AWS Lambda does:

• Fetch user preferences from Amazon DynamoDB
• Generate a prompt combining:
  • Static preferences
  • Retrieved documents from the Knowledge Base
  • Output from the flight API
• Send a prompt to the Amazon Bedrock model and return the response.

Step 7: Expose via Amazon API Gateway

• Create a REST endpoint /recommend
• Connect it to the orchestrator AWS Lambda
• Accept POST request with travel inputs (date, number of travelers, etc.)

Technologies Used

Conclusion

This solution illustrates how developers can build scalable, real-time travel recommendation systems using Amazon Bedrock and Amazon OpenSearch Serverless. The modular architecture allows easy extension into hotel bookings, restaurant suggestions, or even weather-based planning.

Whether you’re building a chatbot for a travel agency or a backend engine for a travel booking portal, this architecture will scale with your needs.

Drop a query if you have any questions regarding Amazon Bedrock and we will get back to you quickly.

About CloudThat