Skip to main content
Glama

Travel MCP Server

An AI-powered travel planner built as a Model Context Protocol (MCP) server. Connect it to Claude and get a full travel assistant — search flights, hotels, weather, and points of interest, generate day-by-day itineraries, and track your trip budget.

A Next.js web UI is included for exploring the tools directly in a browser without a Claude client.

Tools

Tool

Description

search_flights

Search flights between two cities by name or IATA code

search_hotels

Search hotels with optional price filter

get_weather

Day-by-day weather forecast for a destination

search_poi

Points of interest by category (restaurants, attractions, activities, nightlife, shopping, transport)

plan_trip

Generate a complete itinerary with weather, POI, flight & hotel options, and optional budget allocation

create_trip_budget

Create a budget tracker for a trip

add_expense

Record an expense against a budget category

get_budget_summary

Total spent, remaining balance, and per-category breakdown

Supported destinations (mock data)

Flights: New York ↔ Tokyo / Paris / London / Barcelona / Sydney / Bali · London ↔ Paris / Barcelona / Bali · Sydney ↔ Bali · Paris ↔ Rome

Hotels, weather & POI: Tokyo, Paris, London, Barcelona, Bali, Sydney, Rome, Amsterdam, Dubai

Related MCP server: Triplus MCP Server

Quickstart

Prerequisites

  • Python 3.10+, uv — brew install uv

  • Node.js 18+ and pnpm (for the web UI) — brew install pnpm

Run locally (stdio — for Claude Desktop / Claude Code)

git clone <repo-url> travel-mcp-server
cd travel-mcp-server
uv sync
uv run python -m travel_mcp

Run with the web UI

# Terminal 1 — MCP server in SSE mode
MCP_TRANSPORT=sse uv run python -m travel_mcp

# Terminal 2 — Next.js UI
cd ui && pnpm install && pnpm dev

Open http://localhost:3000 to use the browser playground.

Inspect tools interactively

npx @modelcontextprotocol/inspector uv run python -m travel_mcp

Connect to Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "travel-planner": {
      "command": "uv",
      "args": ["run", "--directory", "/absolute/path/to/travel-mcp-server", "python", "-m", "travel_mcp"]
    }
  }
}

Restart Claude Desktop. The 8 travel tools will appear automatically.

Docker

# Build
docker build -t travel-mcp-server .

# Run (SSE transport on port 8000)
docker compose up

The server listens on http://localhost:8000 in SSE mode when running via Docker.

The web UI can be pointed at a remote server by setting MCP_SERVER_URL before starting it:

MCP_SERVER_URL=http://your-server:8000 pnpm --prefix ui dev

Web UI

Kubernetes

# Deploy
kubectl apply -f k8s/

# Verify
kubectl rollout status deployment/travel-mcp-server -n travel-mcp

# Test locally via port-forward
kubectl port-forward svc/travel-mcp-server 8000:80 -n travel-mcp

# Tear down
kubectl delete -f k8s/

Note: The Deployment runs a single replica because budget state is held in memory. Scale to multiple replicas only after adding external storage (Redis, Postgres, etc.).

Web UI

A Next.js 16 app in ui/ that provides a browser-based playground for all 8 tools. It requires the MCP server to be running in SSE mode (MCP_TRANSPORT=sse).

ui/
├── app/
│   ├── page.tsx              # Tabbed playground (Flights, Hotels, Weather, Places, Itinerary, Budget)
│   └── api/tools/[tool]/     # Next.js API route — proxies to MCP server REST endpoints
├── components/               # One component per tool tab + shared UI primitives
└── lib/mcp.ts                # Thin fetch wrapper for /api/tools/*

The MCP server exposes REST endpoints at /api/tools/<tool_name> (POST, JSON body) alongside the standard SSE transport, so the UI does not need to implement the MCP protocol.

Environment variables

Variable

Default

Description

MCP_TRANSPORT

stdio

Transport mode: stdio (local) or sse (HTTP)

HOST

0.0.0.0

Bind address (SSE mode only)

PORT

8000

Port (SSE mode only)

MCP_SERVER_URL

http://localhost:8000

URL the Next.js UI uses to reach the MCP server

Project structure

travel-mcp-server/
├── src/travel_mcp/
│   ├── server.py          # FastMCP instance, tool registrations, REST API routes
│   ├── tools/             # Business logic (one file per domain)
│   │   ├── flights.py
│   │   ├── hotels.py
│   │   ├── weather.py
│   │   ├── poi.py
│   │   ├── itinerary.py   # Composes other tools into a full itinerary
│   │   └── budget.py      # In-memory budget tracker
│   └── mock_data/         # Static fixtures — replace query_* functions to wire real APIs
│       ├── flights.py
│       ├── hotels.py
│       ├── weather.py
│       └── poi.py
├── ui/                    # Next.js web UI
│   ├── app/               # App Router pages and API routes
│   ├── components/        # Tool tab components
│   └── lib/mcp.ts         # MCP server fetch client
├── k8s/                   # Kubernetes manifests
├── Dockerfile
└── docker-compose.yml

Swapping in real APIs

Each mock_data/ file exposes a single query_* function. Replace just that function with an HTTP call to a real provider and everything else stays the same.

Mock file

Suggested real API

mock_data/flights.py

Amadeus Flight Offers

mock_data/hotels.py

Amadeus Hotel Search

mock_data/weather.py

OpenWeatherMap

mock_data/poi.py

Google Places API

Example prompts

  • "Plan a 7-day trip to Tokyo from New York in October with a $4,000 budget."

  • "Find me flights from London to Barcelona for next Friday, 2 passengers."

  • "What's the weather like in Bali in July?"

  • "Show me the top attractions in Rome."

  • "I spent $850 on flights for my Tokyo trip — log it and show my remaining budget."

License

MIT

Available Tools

8 tools
add_expenseA

Record an expense against a trip budget.

Args: trip_id: The trip identifier used when creating the budget category: Expense category — flights, hotels, food, activities, transport, shopping, or misc amount: Amount spent description: Brief description of the expense (e.g. "ANA flight JFK→NRT")

Inputs: trip_id (required), category (required), amount (required), description (required).

create_trip_budgetA

Create a budget tracker for a trip.

Args: trip_id: Unique identifier for the trip (e.g. "tokyo-oct-2024") total_budget: Total budget amount currency: Currency code (default: "USD")

Inputs: trip_id (required), total_budget (required), currency.

get_budget_summaryA

Get a full budget summary: total spent, remaining balance, and per-category breakdown.

Args: trip_id: The trip identifier used when creating the budget

Inputs: trip_id (required).

get_weatherA

Get day-by-day weather forecast for a destination over a date range.

Args: destination: City name (e.g. "Tokyo", "Bali", "Sydney") date_from: Start date in YYYY-MM-DD format date_to: End date in YYYY-MM-DD format

Inputs: destination (required), date_from (required), date_to (required).

plan_tripA

Generate a complete day-by-day travel itinerary combining weather, attractions, dining, and travel options.

Args: destination: Travel destination city (e.g. "Tokyo", "Paris") start_date: Trip start date in YYYY-MM-DD format end_date: Trip end date in YYYY-MM-DD format origin: Departure city for flight search (e.g. "New York", "London") total_budget: Total trip budget in USD — enables budget planning and suggested allocation (optional) preferences: Comma-separated interests to tailor the itinerary (e.g. "food, history, beaches")

Inputs: destination (required), start_date (required), end_date (required), origin (required), +2 more.

search_flightsA

Search for available flights between two cities.

Args: origin: Departure city name or airport code (e.g. "New York" or "JFK") destination: Arrival city name or airport code (e.g. "Tokyo" or "NRT") departure_date: Departure date in YYYY-MM-DD format return_date: Return date for round trips in YYYY-MM-DD format (omit for one-way) passengers: Number of passengers (default: 1)

Inputs: origin (required), destination (required), departure_date (required), return_date, +1 more.

search_hotelsA

Search for available hotels in a destination.

Args: destination: City name (e.g. "Tokyo", "Paris", "London") check_in: Check-in date in YYYY-MM-DD format check_out: Check-out date in YYYY-MM-DD format guests: Number of guests (default: 1) max_price: Maximum price per night in USD (optional)

Inputs: destination (required), check_in (required), check_out (required), guests, +1 more.

search_poiA

Search for points of interest in a destination.

Args: destination: City name (e.g. "Tokyo", "Barcelona", "Rome") category: Type of place — restaurants, attractions, activities, nightlife, shopping, or transport limit: Maximum number of results to return (default: 5)

Inputs: destination (required), category (required), limit.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: budgeting (add_expense, create_trip_budget, get_budget_summary), weather, itinerary planning, flight search, hotel search, and POI search. No overlap in functionality.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case (e.g., add_expense, create_trip_budget, search_flights). No mixing of conventions.

    Tool Count5/5

    8 tools cover the essential travel planning domains (budget, weather, itinerary, flights, hotels, POI) without being excessive or sparse. Well-scoped for a focused travel assistant.

    Completeness4/5

    Covers core travel planning workflows, but minor gaps exist: no budget update/delete, no transportation other than flights, and no tool to modify generated itineraries. Still fairly complete.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A unified MCP server providing a single entry point to comprehensive travel planning services, including flights, hotels, weather, geocoding, events, and finance, for seamless integration with MCP clients like Claude Desktop.
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      A Model Context Protocol (MCP) server for comprehensive travel planning, providing flight search, accommodation booking, currency exchange, weather forecasting, and trip budget calculation capabilities.
      ISC
    • A
      license
      Not graded
      quality
      D
      maintenance
      Coordinates flights, hotels, events, weather, currency, and traffic data through a single MCP server, enabling comprehensive trip planning via natural language prompts.
      MIT