TravelRekha

TravelRekha — Your AI travel companion that plans like a friend, not a template

Comment

Inspiration

Every trip starts with excitement — and then quickly turns into hours of spreadsheet juggling, blog-scrolling, and agency-template frustration. We noticed a fundamental gap: travel agencies and existing planning tools treat every traveler the same. A solo backpacker interested in street food and offbeat trails gets the same cookie-cutter itinerary as a family of five looking for kid-friendly resorts. Dietary restrictions, activity preferences, budget nuances, and group dynamics are ignored or treated as afterthoughts.

We asked ourselves: what if an AI could sit down with you, understand how you like to travel — not just where — and build a plan around that? That question became TravelRekha.

What it does

TravelRekha is a conversational AI travel planner powered by Gemini. Instead of filling out rigid forms, users simply chat with the app. The AI asks the right questions — destination, dates, budget, food preferences, accessibility needs, travel style — and progressively builds a personalized travel plan.

Once the plan is ready, TravelRekha generates an interactive visual timeline with day-by-day nodes containing tasks (bookings, preparations), recommendations (restaurants, activities, hotels, flights), pricing estimates, and priority levels — all streamed in real time via WebSocket so users see their itinerary come to life node by node.

Key capabilities include:

  • Conversational planning — multi-turn chat that collects preferences naturally, with progress tracking (0-100%)
  • Context reuse — remembers preferences from past trips so returning users don't repeat themselves
  • Group travel support — manages multiple travelers with individual preference profiles
  • Interactive timeline — D3.js-powered visualization with detailed element panels for flights, hotels, and restaurants
  • Real-time notifications — alerts for flight changes, weather updates, and booking reminders
  • Live journey assistance — in-timeline chat for help during the actual trip

How we built it

TravelRekha is built as a monorepo with three core services:

  • Frontend: React + TypeScript with Vite, using D3.js for timeline visualization, Socket.IO for real-time updates, and React Hook Form + Zod for input validation.
  • API Service: Node.js + Express with Prisma ORM over PostgreSQL. Handles authentication (local + Google/Facebook OAuth via Passport.js), chat session management, timeline persistence, and WebSocket coordination.
  • AI Service: Python + FastAPI using Google ADK (Agents Development Kit) with Gemini 2.0 Flash. We built 8 specialized AI agents — each responsible for a distinct task: travel planning, timeline generation, context initialization, suggestions, itinerary creation, activity recommendations, general recommendations, and search. This agent-based architecture lets each agent focus on doing one thing well rather than overloading a single prompt.

The streaming pipeline works by having the API service call the AI service for timeline generation, then pushing each node to connected clients via Socket.IO events (new-node, complete-timeline), creating a progressive loading experience.

Shared packages (auth-lib, shared-types, shared-config, shared-utils) keep the codebase DRY across services. Infrastructure is containerized with Docker and includes Kubernetes and Terraform configs for deployment.

Challenges we ran into

  • Multi-agent orchestration: Getting 8 specialized agents to work cohesively — passing context between the planning agent, context initialization agent, and timeline generation agent without losing information — required careful schema design and state management across turns.
  • Streaming timeline rendering: Rendering D3.js timeline nodes progressively as they arrive over WebSocket, while maintaining visual consistency and smooth animation, was a significant frontend challenge.
  • Context window management: Travel plans can accumulate a lot of conversational context. Balancing what to send to Gemini versus what to summarize to stay within token limits, while keeping the AI's responses relevant, took multiple iterations.
  • Plan completeness detection: Teaching the AI to reliably determine when enough information has been gathered (mandatory fields filled, coherent plan formed) without being too aggressive or too passive in asking follow-up questions.

Accomplishments that we're proud of

  • Agent-based architecture with Google ADK: Rather than a single monolithic prompt, we decomposed travel planning into 8 specialized agents. This made each agent's behavior predictable, testable, and independently improvable.
  • Context reuse system: The app remembers previous travel contexts and intelligently suggests reusing them — a returning user planning a similar trip can skip the information-gathering phase almost entirely.
  • Real-time timeline streaming: The progressive node-by-node rendering creates a satisfying visual experience that keeps users engaged instead of staring at a loading spinner.
  • End-to-end personalization pipeline: From dietary restrictions to activity preferences to budget constraints, every data point the user provides actually influences the generated timeline — not just the destinations, but the specific restaurant recommendations, activity timings, and price ranges.

What we learned

  • Agent decomposition matters: Breaking a complex AI task into specialized agents with clear input/output contracts produces far more reliable results than a single do-everything prompt. Each agent can be tuned independently.
  • Streaming improves perceived quality: Users perceive a progressively loading timeline as faster and more thoughtful than one that appears all at once after a delay, even when the total wait time is the same.
  • Travel planning is deeply personal: Through user testing, we learned that preferences we initially considered "optional" (food restrictions, travel pace, morning-vs-evening activity preference) were actually dealbreakers for many users. Personalization isn't a feature — it's the core product.
  • Real-time architecture adds complexity but is worth it: Socket.IO added significant engineering overhead, but the ability to stream AI-generated content and push live notifications transformed the user experience from "tool" to "companion."

What's next for TravelRekha

  • Live API integrations: Connect the search agent to real flight, hotel, and restaurant APIs (Google Places, Skyscanner, Booking.com) to replace current mock data with live pricing and availability.
  • Collaborative trip planning: Enable multiple users to join the same planning session, chat together with the AI, and co-edit timelines in real time.
  • On-trip mode: Expand the live journey assistance with GPS-aware recommendations, real-time rebooking when plans change, and proactive alerts based on current location.
  • Booking integration: Allow users to book flights, hotels, and activities directly from timeline elements without leaving the app.
  • Offline support: Cache timelines and essential trip data for use in areas with limited connectivity.
  • Multi-language support: Extend the AI agents to plan and communicate in the traveler's preferred language.

Built With

Share this project:

Updates