AI Travel Planner

This guide demonstrates how to build a revolutionary AI-powered travel planning platform that transforms how travelers discover, plan, and book their trips. Instead of traditional keyword searches and manual browsing, your platform will understand natural language queries and provide intelligent, personalized travel recommendations using HydraDB’s advanced AI capabilities.

Note: All code in this guide uses the official HydraDB TypeScript SDK. Base URL: https://api.hydradb.com. Get your API key at app.hydradb.com.

Prerequisites

Required knowledge: TypeScript/JavaScript basics, REST APIs, environment variables
Required tools:

HydraDB API key
Node.js 18+ (node --version)
npm install @hydradb/sdk

What You’ll Build

By the end of this cookbook, you’ll be able to:

Upload hotel, flight, restaurant, and activity data into HydraDB with correct database scoping
Answer complex natural language travel queries like “Plan a 5-day romantic trip to Italy for $3000” using fullRecall with mode: "thinking"
Store per-user travel preferences and booking history as AI memories for personalized recommendations
Build family, business, and adventure trip planning flows using semantic search

The Problem with Traditional Travel Planning

Traditional travel platforms force users to think like search engines:

Keyword matching: “Hotels in Paris” or “Flights to Tokyo”
Filter-heavy interfaces: Complex combinations of dates, prices, and amenities
Manual research: Hours spent comparing options across multiple sites
Generic recommendations: One-size-fits-all suggestions that ignore personal preferences
Fragmented experience: Separate searches for flights, hotels, activities, and restaurants

The AI-Powered Solution

With HydraDB, travelers can plan naturally and get personalized recommendations:

“Plan a 5-day romantic trip to Italy for my anniversary in September with a budget of $3000”
“Find me a family-friendly resort in Bali with a kids club and water sports activities”
“I want to experience authentic local cuisine in Bangkok - suggest restaurants and food tours”
“Plan a solo backpacking trip through Southeast Asia for 3 weeks, focusing on cultural experiences”
“Find pet-friendly accommodations in San Francisco with easy access to dog parks”

Architecture Overview

Step 1: Travel Data Ingestion Strategy

1.1 Hotel and Accommodation Data

Start by uploading comprehensive hotel and accommodation data using HydraDB’s knowledge upload API:

import { HydraDBClient } from "@hydradb/sdk";

const client = new HydraDBClient({ token: process.env.HYDRA_DB_API_KEY });

const uploadHotelData = async (hotels, database, collection) => {
  const hotelSources = hotels.map(hotel => ({
    id: `hotel_${hotel.id}`,
    database: database,
    collection: collection,
    title: hotel.name,
    type: "accommodation",
    description: hotel.description,
    timestamp: new Date().toISOString(),
    content: {
      text: `${hotel.name} - ${hotel.description}. Located in ${hotel.city}, ${hotel.country}.
             Amenities: ${hotel.amenities.join(', ')}.
             Average rating: ${hotel.rating}/5 from ${hotel.reviewCount} reviews.
             Price range: ${hotel.priceRange}.
             Room types: ${hotel.roomTypes.join(', ')}.`,
    },
    additional_metadata: {
      location: hotel.coordinates,
      priceRange: hotel.priceRange,
      rating: hotel.rating,
      amenities: hotel.amenities,
      propertyType: hotel.propertyType
    }
  }));

  await client.context.ingest({
    database: database,
    collection: collection,
    appKnowledge: JSON.stringify(hotelSources),
    upsert: true,
  });
};

1.2 Flight and Transportation Data

Upload flight schedules, routes, and transportation options:

const uploadFlightData = async (flights, database, collection) => {
  const flightSources = flights.map(flight => ({
    id: `flight_${flight.id}`,
    database: database,
    collection: collection,
    title: `${flight.airline} ${flight.flightNumber}`,
    type: "transportation",
    description: `Flight from ${flight.origin} to ${flight.destination}`,
    timestamp: new Date().toISOString(),
    content: {
      text: `${flight.airline} flight ${flight.flightNumber} from ${flight.origin} to ${flight.destination}.
             Duration: ${flight.duration}.
             Aircraft: ${flight.aircraft}.
             Departure: ${flight.departureTime}.
             Arrival: ${flight.arrivalTime}.`,
    },
    additional_metadata: {
      origin: flight.origin,
      destination: flight.destination,
      airline: flight.airline,
      duration: flight.duration,
      price: flight.price,
      class: flight.class
    }
  }));

  await client.context.ingest({
    database: database,
    collection: collection,
    appKnowledge: JSON.stringify(flightSources),
    upsert: true,
  });
};

1.3 Restaurant and Dining Data

Upload restaurant information with cuisine types and reviews:

const uploadRestaurantData = async (restaurants, database, collection) => {
  const restaurantSources = restaurants.map(restaurant => ({
    id: `restaurant_${restaurant.id}`,
    database: database,
    collection: collection,
    title: restaurant.name,
    type: "dining",
    description: restaurant.description,
    timestamp: new Date().toISOString(),
    content: {
      text: `${restaurant.name} - ${restaurant.description}.
             Cuisine: ${restaurant.cuisine}.
             Location: ${restaurant.address}.
             Price range: ${restaurant.priceRange}.
             Rating: ${restaurant.rating}/5.
             Specialties: ${restaurant.specialties.join(', ')}.`,
    },
    additional_metadata: {
      cuisine: restaurant.cuisine,
      priceRange: restaurant.priceRange,
      rating: restaurant.rating,
      location: restaurant.coordinates,
      dietaryOptions: restaurant.dietaryOptions
    }
  }));

  await client.context.ingest({
    database: database,
    collection: collection,
    appKnowledge: JSON.stringify(restaurantSources),
    upsert: true,
  });
};

1.4 Activity and Attraction Data

Upload tourist attractions, activities, and experiences:

const uploadActivityData = async (activities, database, collection) => {
  const activitySources = activities.map(activity => ({
    id: `activity_${activity.id}`,
    database: database,
    collection: collection,
    title: activity.name,
    type: "activity",
    description: activity.description,
    timestamp: new Date().toISOString(),
    content: {
      text: `${activity.name} - ${activity.description}.
             Category: ${activity.category}.
             Duration: ${activity.duration}.
             Difficulty: ${activity.difficulty}.
             Best time to visit: ${activity.bestSeason}.
             Price: ${activity.price}.`,
    },
    additional_metadata: {
      category: activity.category,
      duration: activity.duration,
      difficulty: activity.difficulty,
      price: activity.price,
      ageGroup: activity.ageGroup
    }
  }));

  await client.context.ingest({
    database: database,
    collection: collection,
    appKnowledge: JSON.stringify(activitySources),
    upsert: true,
  });
};

Step 2: Building the AI Travel Assistant

2.1 Natural Language Query Processing

Create a travel query handler that understands complex travel requests:

class TravelAssistant {
  constructor(client) {
    this.client = client;
  }

  async planTrip(query, userProfile) {
    // Use HydraDB's thinking mode for complex travel planning
    const response = await this.client.query({
      query: query,
      database: userProfile.database,
      collection: userProfile.collection,
      mode: "thinking",
      alpha: "auto",
      maxResults: 20
    });

    return this.processResponse(response);
  }

  async processResponse(response) {
    // Generate structured itinerary from AI response
    return {
      chunks: response.data?.chunks,
      graphRelations: response.data?.graphContext?.chunkRelations,
      queryPaths: response.data?.graphContext?.queryPaths
    };
  }
}

2.2 Personalized Recommendation Engine

Implement AI memories to remember user preferences and past travel patterns:

class PersonalizationEngine {
  constructor(client) {
    this.client = client;
  }

  async generateUserMemory(userInteraction) {
    // Generate memories based on user's travel preferences and booking patterns
    await client.context.ingest({
      type: 'memory',
      database: userInteraction.database,
      collection: userInteraction.userId,
      upsert: true,
      memories: [{
        id: `user_${userInteraction.userId}`,
        text: `User searched for: ${userInteraction.query}.
                   They showed interest in: ${userInteraction.clickedItems.join(', ')}.
                   They booked: ${userInteraction.bookedItems.join(', ')}.`,
        infer: true,
        user_name: userInteraction.userName
      }]
    });
  }

  async getPersonalizedRecommendations(database, collection, destination) {
    // Retrieve user memories to provide personalized recommendations
    const memories = await this.client.query({
      type: "memory",
      database: database,
      collection: collection,
      query: `travel preferences for ${destination}`,
      maxResults: 10
    });

    // memories.chunks contains the user's past preference signals ranked by relevance.
    // Pass these as context to your LLM to generate personalized recommendations.
    return memories.data?.chunks;
  }
}

Step 3: Advanced Search Capabilities

3.1 Semantic Search for Travel Experiences

Implement semantic search to understand complex travel desires:

const searchTravelExperiences = async (query, database, collection, filters = {}) => {
  const searchQuery = `${query} ${filters.destination ? `in ${filters.destination}` : ''}
                       ${filters.budget ? `budget ${filters.budget}` : ''}
                       ${filters.travelStyle ? `${filters.travelStyle} travel` : ''}`;

  const response = await client.query({
    query: searchQuery,
    database: database,
    collection: collection,
    mode: "fast",
    alpha: 1.0,
    maxResults: 20
  });

  return response;
};

Support different types of travel queries:

const handleTravelQuery = async (query, context) => {
  // HydraDB's semantic search handles all query types without manual classification.
  // Use mode: "thinking" for complex multi-part queries (full itineraries, comparisons).
  // Use mode: "fast" for single-category lookups (hotels only, flights only).
  const isComplex = /itinerary|plan|trip|vacation|week|days/i.test(query);

  const response = await client.query({
    query,
    database: context.database,
    collection: context.collection,
    mode: isComplex ? "thinking" : "fast",
    maxResults: isComplex ? 20 : 10
  });

  return response.data.chunks;
};

Step 4: Real-World Implementation Examples

4.1 Family Vacation Planning

User Query: “Plan a 7-day family vacation to Orlando with kids aged 8 and 12, budget $4000, we love theme parks and want kid-friendly restaurants”

const planFamilyVacation = async (query, userProfile) => {
  const response = await client.query({
    query: query,
    database: userProfile.database,
    collection: userProfile.collection,
    mode: "thinking",
    maxResults: 20
  });

  // Filter chunks by type to build a structured itinerary.
  // response.data.chunks are ranked by AI relevance — filter by metadata type to categorize.
  const itinerary = {
    accommodation: response.data.chunks.filter(c => c.metadata?.type === "accommodation"),
    activities:    response.data.chunks.filter(c => c.metadata?.type === "activity"),
    dining:        response.data.chunks.filter(c => c.metadata?.type === "dining"),
    transportation: response.data.chunks.filter(c => c.metadata?.type === "transportation")
  };

  return itinerary;
};

4.2 Business Travel Optimization

User Query: “I need to travel to London for business next week, find hotels near financial district with good WiFi and meeting rooms”

const planBusinessTravel = async (query, userProfile) => {
  const response = await client.query({
    query: query,
    database: userProfile.database,
    collection: userProfile.collection,
    mode: "fast",
    maxResults: 10
  });

  // Return ranked chunks directly. Filter by metadata.amenities or metadata.location as needed.
  return response.data.chunks;
};

4.3 Adventure Travel Planning

User Query: “I want to go trekking in Nepal for 2 weeks, suggest routes for intermediate hikers with cultural experiences”

const planAdventureTravel = async (query, userProfile) => {
  const response = await client.query({
    query: query,
    database: userProfile.database,
    collection: userProfile.collection,
    mode: "thinking",
    maxResults: 15
  });

  // Return ranked chunks directly. Sort or filter by metadata.difficulty for hiking-specific results.
  return response.data.chunks;
};

Step 5: Contextual Recommendations

5.1 Weather-Based Suggestions

const getWeatherBasedRecommendations = async (destination, travelDate, database, collection) => {
  const weatherQuery = `What activities and attractions are best in ${destination} during ${travelDate} considering weather conditions?`;

  const response = await client.query({
    query: weatherQuery,
    database: database,
    collection: collection,
    mode: "fast",
    maxResults: 10
  });

  return response;
};

5.2 Cultural Event Integration

const getCulturalEventRecommendations = async (destination, travelDate, database, collection) => {
  const eventQuery = `What cultural events, festivals, or seasonal experiences are happening in ${destination} during ${travelDate}?`;

  const response = await client.query({
    query: eventQuery,
    database: database,
    collection: collection,
    mode: "fast",
    maxResults: 10
  });

  return response;
};

Step 6: Learning from User Behavior

6.1 Booking Pattern Analysis

const analyzeBookingPatterns = async (database, collection, bookingData) => {
  const analysisText = `User has booked: ${bookingData.map(b => b.description).join(', ')}. What patterns can we identify about their travel preferences?`;

  // Generate memory for future personalization
  await client.context.ingest({
    type: 'memory',
    database: database,
    collection: collection,
    upsert: true,
    memories: [{
      id: `booking_${database}`,
      text: analysisText,
      infer: true,
      user_name: bookingData[0].userName
    }]
  });
};

const refineSearch = async (originalQuery, userFeedback, database, collection) => {
  const refinedQuery = `${originalQuery}. User feedback: ${userFeedback}. Please adjust recommendations accordingly.`;

  const response = await client.query({
    query: refinedQuery,
    database: database,
    collection: collection,
    mode: "thinking",
    maxResults: 10
  });

  return response;
};

Advanced Features

Multi-Language Support

const handleMultiLanguageQuery = async (query, language, destination, database, collection) => {
  const localizedQuery = `${query} (query in ${language} for ${destination})`;

  const response = await client.query({
    query: localizedQuery,
    database: database,
    collection: collection,
    mode: "fast",
    maxResults: 10
  });

  return response;
};

Real-Time Price Monitoring

const monitorPriceChanges = async (travelPlan) => {
  const priceText = `Monitor price changes for: ${travelPlan.description}. Alert if prices drop by 10% or more.`;

  // Set up monitoring using HydraDB memories
  await client.context.ingest({
    type: 'memory',
    database: travelPlan.database,
    collection: travelPlan.userId,
    upsert: true,
    memories: [{
      id: `price_${travelPlan.userId}`,
      text: priceText,
      infer: true
    }]
  });
};

Example User Interactions

Scenario 1: Spontaneous Weekend Trip

User: “I want to go somewhere warm this weekend, budget $800, flying from New York” AI Response: Based on your budget and preference for warm weather, I recommend:

Miami, Florida: 3-day weekend package with beachfront hotel and flights for $750
Austin, Texas: Music and food scene with boutique hotel for $680
Savannah, Georgia: Historic charm with B&B accommodation for $620

Scenario 2: Anniversary Celebration

User: “Plan a romantic anniversary trip to Paris for 5 days in May, we love art museums and fine dining” AI Response: For your romantic Paris anniversary:

Accommodation: Hotel des Grands Boulevards in the 2nd arrondissement
Day 1: Louvre Museum morning, Seine river cruise evening
Day 2: Musée d’Orsay, dinner at L’Ambroisie (Michelin 3-star)
Day 3: Montmartre walking tour, Picasso Museum
Day 4: Versailles day trip, romantic dinner at Le Meurice
Day 5: Rodin Museum, farewell lunch at L’Atelier de Joël Robuchon

Scenario 3: Solo Adventure Planning

User: “I’m planning a solo backpacking trip through Southeast Asia for a month, focusing on cultural immersion and budget-friendly options” AI Response: Your month-long Southeast Asia adventure:

Route: Thailand → Vietnam → Cambodia → Laos
Budget: $2,000-2,500 total
Accommodation: Mix of hostels and homestays
Cultural experiences: Cooking classes, temple visits, local festivals
Transportation: Buses and trains for authentic experience

Integration with Booking Systems

Real-Time Availability Checking

const checkAvailability = async (hotelId, checkIn, checkOut, database, collection) => {
  const availabilityQuery = `Check availability for ${hotelId} from ${checkIn} to ${checkOut}`;

  const response = await client.query({
    query: availabilityQuery,
    database: database,
    collection: collection,
    mode: "fast",
    maxResults: 5
  });

  return response;
};

Dynamic Pricing Integration

const getDynamicPricing = async (searchResults, userProfile) => {
  const pricingQuery = `Get current pricing for these travel options considering user's booking history and preferences`;

  const response = await client.query({
    query: pricingQuery,
    database: userProfile.database,
    collection: userProfile.collection,
    mode: "fast",
    maxResults: 10
  });

  return response;
};

Conclusion

Building an AI travel planner with HydraDB transforms the travel planning experience from a tedious research process into an intelligent, conversational journey. By leveraging HydraDB’s AI memories, multi-step reasoning, and semantic search capabilities, you can create a platform that truly understands traveler intent and provides personalized recommendations. Key benefits of this approach:

Natural Language Understanding: Users can express complex travel desires in natural language
Personalized Recommendations: AI memories ensure recommendations improve over time
Contextual Awareness: Multi-step reasoning considers all aspects of travel planning
Seamless Integration: Easy integration with existing booking systems and travel APIs

The result is a travel planning platform that feels more like having a knowledgeable travel advisor than using a search engine, creating higher user satisfaction and better conversion rates for travel businesses.

Cookbooks

Prerequisites

What You’ll Build

The Problem with Traditional Travel Planning

The AI-Powered Solution

Architecture Overview

Step 1: Travel Data Ingestion Strategy

1.1 Hotel and Accommodation Data

1.2 Flight and Transportation Data

1.3 Restaurant and Dining Data

1.4 Activity and Attraction Data

Step 2: Building the AI Travel Assistant

2.1 Natural Language Query Processing

2.2 Personalized Recommendation Engine

Step 3: Advanced Search Capabilities

3.1 Semantic Search for Travel Experiences

Step 4: Real-World Implementation Examples

4.1 Family Vacation Planning

4.2 Business Travel Optimization

4.3 Adventure Travel Planning

Step 5: Contextual Recommendations

5.1 Weather-Based Suggestions

5.2 Cultural Event Integration

Step 6: Learning from User Behavior

6.1 Booking Pattern Analysis

6.2 Search Refinement

Advanced Features

Multi-Language Support

Real-Time Price Monitoring

Example User Interactions

Scenario 1: Spontaneous Weekend Trip

Scenario 2: Anniversary Celebration

Scenario 3: Solo Adventure Planning

Integration with Booking Systems

Real-Time Availability Checking

Dynamic Pricing Integration

Conclusion

​Prerequisites

​What You’ll Build

​The Problem with Traditional Travel Planning

​The AI-Powered Solution

​Architecture Overview

​Step 1: Travel Data Ingestion Strategy

​1.1 Hotel and Accommodation Data

​1.2 Flight and Transportation Data

​1.3 Restaurant and Dining Data

​1.4 Activity and Attraction Data

​Step 2: Building the AI Travel Assistant

​2.1 Natural Language Query Processing

​2.2 Personalized Recommendation Engine

​Step 3: Advanced Search Capabilities

​3.1 Semantic Search for Travel Experiences

​3.2 Multi-Modal Travel Search

​Step 4: Real-World Implementation Examples

​4.1 Family Vacation Planning

​4.2 Business Travel Optimization

​4.3 Adventure Travel Planning

​Step 5: Contextual Recommendations

​5.1 Weather-Based Suggestions

​5.2 Cultural Event Integration

​Step 6: Learning from User Behavior

​6.1 Booking Pattern Analysis

​6.2 Search Refinement

​Advanced Features

​Multi-Language Support

​Real-Time Price Monitoring

​Example User Interactions

​Scenario 1: Spontaneous Weekend Trip

​Scenario 2: Anniversary Celebration

​Scenario 3: Solo Adventure Planning

​Integration with Booking Systems

​Real-Time Availability Checking

​Dynamic Pricing Integration

​Conclusion

Prerequisites

What You’ll Build

The Problem with Traditional Travel Planning

The AI-Powered Solution

Architecture Overview

Step 1: Travel Data Ingestion Strategy

1.1 Hotel and Accommodation Data

1.2 Flight and Transportation Data

1.3 Restaurant and Dining Data

1.4 Activity and Attraction Data

Step 2: Building the AI Travel Assistant

2.1 Natural Language Query Processing

2.2 Personalized Recommendation Engine

Step 3: Advanced Search Capabilities

3.1 Semantic Search for Travel Experiences

3.2 Multi-Modal Travel Search

Step 4: Real-World Implementation Examples

4.1 Family Vacation Planning

4.2 Business Travel Optimization

4.3 Adventure Travel Planning

Step 5: Contextual Recommendations

5.1 Weather-Based Suggestions

5.2 Cultural Event Integration

Step 6: Learning from User Behavior

6.1 Booking Pattern Analysis

6.2 Search Refinement

Advanced Features

Multi-Language Support

Real-Time Price Monitoring

Example User Interactions

Scenario 1: Spontaneous Weekend Trip

Scenario 2: Anniversary Celebration

Scenario 3: Solo Adventure Planning

Integration with Booking Systems

Real-Time Availability Checking

Dynamic Pricing Integration

Conclusion