Build a Multi-Agent Travel Finder in Python with LangGraph

import re

CITY_CODES = {"indore": "IDR", "goa": "GOI", "mumbai": "BOM", "delhi": "DEL"}

def fake_llm_parse(text):
    t = text.lower()
    cities = [CITY_CODES[c] for c in re.findall(r"[a-z]+", t) if c in CITY_CODES]
    dates = re.search(r"(\d{1,2})\s*(?:-|to)\s*(\d{1,2})\s*dec", t)
    people = re.search(r"(\d+)\s*(?:friends|people|adults)", t)
    budget = re.search(r"rs\s*([\d,]+)", t)
    return {"origin": cities[0] if cities else None,
            "destination": cities[1] if len(cities) > 1 else None,
            "nights": int(dates[2]) - int(dates[1]) if dates else None,
            "travellers": int(people[1]) if people else None,
            "budget_rs": int(budget[1].replace(",", "")) if budget else None}

QUESTIONS = {"origin": "Which city are you leaving from?", "destination": "Where do you want to go?",
             "nights": "Which dates are you travelling?", "travellers": "How many people are going?",
             "budget_rs": "What is your total budget?"}

def validate(req):
    missing = [k for k, v in req.items() if v is None]
    return f"Ask the user: {QUESTIONS[missing[0]]}" if missing else "ok"

for text in ["4 friends, Indore to Goa, 20 to 23 Dec, under Rs 40,000 total",
             "Indore to Goa for 2 people under Rs 25,000"]:
    req = fake_llm_parse(text)
    print(req, "->", validate(req))

FLIGHTS = [  # IDR -> GOI, fare per person (round trip), stops, departure
    {"id": "SL-101", "fare": 6400, "stops": 0, "departs": "06:10"},
    {"id": "SL-215", "fare": 5200, "stops": 1, "departs": "11:45"},
    {"id": "BX-330", "fare": 4800, "stops": 2, "departs": "23:55"},
]
HOTELS = [
    {"name": "Sea Breeze Resort", "stars": 4, "per_night": 5200, "rating": 4.4},
    {"name": "Palm Grove Inn", "stars": 3, "per_night": 3200, "rating": 4.1},
    {"name": "Calangute Stay", "stars": 3, "per_night": 2700, "rating": 3.6},
]

def flight_agent(max_stops=1):
    ok = [f for f in FLIGHTS if f["stops"] <= max_stops]
    return sorted(ok, key=lambda f: f["fare"] + 800 * f["stops"])   # a stop "costs" Rs 800

def hotel_agent(max_stars=4, min_rating=4.0):
    ok = [h for h in HOTELS if h["stars"] <= max_stars and h["rating"] >= min_rating]
    return sorted(ok, key=lambda h: (-h["stars"], h["per_night"]))

print("Flights:", [f"{f['id']} Rs {f['fare']}" for f in flight_agent()])
print("Hotels (4-star max):", [h["name"] for h in hotel_agent()])
print("Hotels (3-star max):", [h["name"] for h in hotel_agent(max_stars=3)])

FLIGHTS = [{"id": "SL-215", "fare": 5200, "departs": "11:45"}]
HOTELS = [{"name": "Sea Breeze Resort", "stars": 4, "per_night": 5200},
          {"name": "Palm Grove Inn", "stars": 3, "per_night": 3200}]
req = {"origin": "IDR", "destination": "GOI", "nights": 3, "travellers": 4, "budget_rs": 40000}

def total_cost(flight, hotel, req):
    rooms = -(-req["travellers"] // 2)                     # 2 people per room, rounded up
    return flight["fare"] * req["travellers"] + hotel["per_night"] * req["nights"] * rooms

max_stars, attempts = 4, 0
while True:
    attempts += 1
    hotel = min((h for h in HOTELS if h["stars"] <= max_stars), key=lambda h: -h["stars"])
    flight, total = FLIGHTS[0], total_cost(FLIGHTS[0], hotel, req)
    print(f"Attempt {attempts}: {hotel['name']} -> Rs {total:,}")
    if total <= req["budget_rs"] or attempts == 2:
        break
    max_stars -= 1                                          # relax one constraint

status = "within budget" if total <= req["budget_rs"] else "over budget, shown with a warning"
print(f"\nItinerary ({status}):\n  Fly {flight['id']} {req['origin']} to {req['destination']}, departs {flight['departs']}"
      f"\n  Stay {req['nights']} nights at {hotel['name']}\n  Total Rs {total:,}, Rs {total // req['travellers']:,} each")

from typing import TypedDict
from pydantic import BaseModel
from openai import OpenAI
from langgraph.graph import StateGraph, START, END

client = OpenAI()

class TripRequest(BaseModel):
    origin: str
    destination: str
    depart_date: str
    return_date: str
    travellers: int
    budget_rs: int
    max_hotel_stars: int = 4

class TripState(TypedDict, total=False):
    query: str
    request: dict
    flights: list
    hotels: list
    plan: dict
    attempts: int
    itinerary: str

def parse_request(state: TripState) -> dict:
    response = client.responses.parse(
        model="your-model-name",
        instructions="Extract the trip details. Use IATA airport codes and ISO dates.",
        input=state["query"], text_format=TripRequest)
    return {"request": response.output_parsed.model_dump(), "attempts": 0}

def find_flights(state: TripState) -> dict:
    return {"flights": search_flights_api(**state["request"])}     # your provider

def find_hotels(state: TripState) -> dict:
    return {"hotels": search_hotels_api(**state["request"])}       # your provider

def check_budget(state: TripState) -> dict:
    plan = cheapest_combination(state["flights"], state["hotels"], state["request"])  # plain code
    return {"plan": plan, "attempts": state["attempts"] + 1}

def route_after_budget(state: TripState) -> str:
    fits = state["plan"]["total"] <= state["request"]["budget_rs"]
    return "write" if fits or state["attempts"] >= 2 else "relax"

def relax(state: TripState) -> dict:
    req = dict(state["request"])
    req["max_hotel_stars"] = max(2, req["max_hotel_stars"] - 1)
    return {"request": req}

def write_itinerary(state: TripState) -> dict:
    response = client.responses.create(model="your-model-name",
        input=f"Write a short, friendly itinerary from this plan only: {state['plan']}")
    return {"itinerary": response.output_text}

graph = StateGraph(TripState)
for name, fn in [("parse", parse_request), ("flights", find_flights), ("hotels", find_hotels),
                 ("budget", check_budget), ("relax", relax), ("write", write_itinerary)]:
    graph.add_node(name, fn)
graph.add_edge(START, "parse")
graph.add_edge("parse", "flights"); graph.add_edge("parse", "hotels")      # run in parallel
graph.add_edge("flights", "budget"); graph.add_edge("hotels", "budget")
graph.add_conditional_edges("budget", route_after_budget, {"write": "write", "relax": "relax"})
graph.add_edge("relax", "hotels")
graph.add_edge("write", END)
app = graph.compile()

result = app.invoke({"query": "4 friends, Indore to Goa, 20 to 23 Dec 2026, under Rs 40,000 total"})
print(result["itinerary"])