MoltTravel

One MCP server. Every travel tool.

Search flights, compare prices, check visas, look up airports,<br> get travel advisories — through a single endpoint.

  Kiwi.com    Navifare     Peek.com    LastMinute
  (flights)   (prices)   (experiences)  (flights)
      \          |           |          /
       \         |           |         /
        +--------+-----------+--------+
        |                             |
        |    MoltTravel MCP Server    |
        |                             |
        |  Airports  Airlines  Visas  |
        |  Countries  FCDO  Gemini AI |
        |                             |
        +-------------|---------------+
                      |
               MCP over HTTP
                      |
              Any MCP Client
        (Claude, Cursor, your app)

Why?

Travel data is scattered across dozens of APIs, each with its own auth, format, and quirks. MoltTravel aggregates them behind a single Model Context Protocol endpoint:

• 21+ tools from 4 upstream MCP providers + 6 built-in datasets
• Zero config for static data — airports, airlines, and visas load lazily with no API keys
• Schema-transparent proxy — clients see the real upstream JSON Schema; upstream servers validate their own args
• One line to connect from Claude Desktop, Claude Code, Cursor, or any MCP client

Quick Start

git clone https://github.com/navifare/moltravel-mcp.git
cd moltravel-mcp
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
python molttravel_server.py

Server starts at http://localhost:8000/mcp. That's it.

Connect Your Client

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "molttravel": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

Add to .claude/settings.json:

{
  "mcpServers": {
    "molttravel": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client("http://localhost:8000/mcp") as (r, w, _):
    async with ClientSession(r, w) as session:
        await session.initialize()
        tools = await session.list_tools()
        result = await session.call_tool("airports_lookup", {"code": "ZRH"})

Tools

Flights & Pricing

Experiences & Activities

Reference Data _{(built-in, no API keys needed)}

Natural Language _(optional)

Requires GEMINI_API_KEY. Example: "Cheapest flights from Zurich to Rome next week, and do I need a visa?"

How It Works

1. Tool Discovery

On startup, MoltTravel connects to each upstream MCP server, calls tools/list, and registers every discovered tool with a {provider}_{tool_name} prefix:

kiwi       → kiwi_search-flight, kiwi_feedback-to-devs
navifare   → navifare_flight_pricecheck, navifare_format_flight_pricecheck_request
peek       → peek_search_experiences, peek_experience_details, ...
lastminute → (discovered at runtime)

Native tools (airports, airlines, visas, countries, FCDO) are registered directly.

2. Schema-Transparent Proxy

Clients see the original upstream JSON Schema for each tool — enums, nested objects, $ref, everything. Internally, MoltTravel uses a permissive Pydantic model (Any for all fields) so arguments pass through without lossy validation. The upstream MCP server validates its own args.

# Client sees the real schema
parameters = input_schema          # original from upstream

# Server doesn't re-validate types — just passes through
fields[prop_name] = (Any, Field(default=None))

3. Lazy Data Loading

Static datasets (airports, airlines, visas) download on first use behind async locks. No startup penalty, no wasted bandwidth if you only use flight tools.

Configuration

Deployment

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "molttravel_server.py"]

docker build -t molttravel .
docker run -p 8000:8000 molttravel

The server reads PORT from the environment and binds to 0.0.0.0 — it works out of the box on any container platform. Just point the start command at python molttravel_server.py.

Project Structure

moltravel-mcp/
├── molttravel_server.py        # Server core — proxy logic, native tools, routing
├── requirements.txt            # mcp[cli], httpx
├── test_search.py              # Integration test client
└── providers/
    ├── __init__.py             # MCP_PROVIDERS registry + exports
    ├── mcp_client.py           # Generic HTTP client for upstream MCP servers
    ├── data_loader.py          # CSV downloader + haversine distance
    ├── airports.py             # 45K airports from OurAirports
    ├── airlines.py             # 7K airlines from OpenFlights
    ├── visas.py                # Visa requirements from Passport Index
    ├── restcountries.py        # REST Countries API
    ├── fcdo.py                 # UK FCDO travel advisories
    └── gemini.py               # Gemini Flash tool router

Extending

Add an MCP provider

Add one line to providers/__init__.py and restart:

MCP_PROVIDERS = {
    "kiwi": McpClient("https://mcp.kiwi.com/mcp"),
    "navifare": McpClient("https://mcp.navifare.com/mcp"),
    "peek": McpClient("https://mcp.peek.com/mcp"),
    "your_provider": McpClient("https://mcp.example.com/mcp"),  # new
}

Tools are discovered and registered automatically as your_provider_{tool_name}.

Add a native tool

@server.tool(name="my_tool")
async def my_tool(query: str) -> str:
    """Description shown to MCP clients."""
    return "result"

Data Sources & Licenses

Contributing

1. Fork the repo
2. Create a branch (git checkout -b feature/my-feature)
3. Make changes and test (python molttravel_server.py)
4. Open a pull request

License

MIT