Abstract:

Travel Mate is an intelligent multi-agent travel planning system designed to simplify trip preparation by combining weather forecasting, budget optimization, destination discovery, and personalized itinerary generation. Built using a modular agent architecture, the system orchestrates multiple specialized agents through a central controller, enabling dynamic decision-making and tool-supported reasoning. The project integrates real-time APIs Open weather, Yelp, Groq, and HuggingFace while maintaining strong safety, fault tolerance, and reproducibility standards required for production ready workflow automation.

Introduction:

Planning a holiday often requires browsing destinations, checking weather, comparing budgets, and selecting activities, which can be overwhelming. Travel Mate automates this entire workflow through a coordinated team of intelligent agents. Each agent focuses on a specific part of the decision making pipeline and collaborates using LangGraph powered orchestration. The system transforms raw user inputs into a structured and optimized travel plan.
This publication demonstrates the full multi-agent workflow, the supporting tools, architecture, and experiments performed to ensure reliability.

System Architecture:

The system follows a hub-and-spoke multi-agent design. Each agent performs a single well defined function, and the central orchestrator manages message routing, memory sharing, and graph transitions.

Methodology:

Travel Mate relies on an iterative and tool assisted and decision making pipeline:

• User Input Interpretation:
  The system extracts destination, budget, duration, and travel preferences from the user prompt.

• Destination Feasibility Analysis:
  A domain agent checks destination plausibility and refines preferences.

• Weather Forecast Retrieval:
  Weather data is fetched from OpenWeather and normalized for downstream tasks.

• Budget Optimization:
  The Budget Agent evaluates spending categories and aligns them with the user’s constraints.

• Itinerary Generation:
  Yelp results, local attractions, and preferences are synthesized into a structured day-by-day plan.

• Result Formatting:
  Final output is generated using Groq or HuggingFace LLM inference.

• Metrics Logging:
  Execution time, agent hops, API calls, and safety filters feed into a Metrics Agent for evaluation.

Agent Roles:

Each agent performs a distinct capability, ensuring modularity and clarity.

Input Agent:

Parses user request
Validates inputs
Extracts destination, dates, budget, and preferences
Passes structured JSON to next agents

Destination Agent:

Refines or corrects the destination
Enriches metadata (country, region, known attractions)
Ensures feasibility

Weather Agent:

Calls OpenWeather API
Returns 5–7 day weather summary
Flags extreme conditions
Provides weather-based warnings for itinerary adjustments

Budget Agent:

Processes budget constraints suggest lodging/food/activity costs
Identifies cost-saving alternatives.

Itinerary Agent:

Combines weather, budget, and attractions uses Yelp API for points of interest
Produces optimized day-by-day schedule.

Result Agent:

Merges all outputs
Formats final JSON travel plan and applies HuggingFace summarization for cleaner text.

Metrics Agent:

Logs execution metadata produces runtime report useful for performance evaluation.

Data Flow:

Information moves through a LangGraph workflow:

Input Agent  
   ↓  
Destination Agent  
   ↓  
Weather Agent  
   ↓  
Budget Agent  
   ↓  
Itinerary Agent  
   ↓  
Result Agent  
   ↓  
Metrics Agent

Each step passes validated, structured data to the next agent through the orchestrator.

Technical Stack:

LangGraph:

for multi-agent orchestration

Python 3.10+

OpenWeather API :

weather forecasts:
Yelp API – places & activities

Groq API:

fast LLM inference

HuggingFace Inference API:

summarization

requests / logging:

production support

dotenv:

for secure secret management.

Project Structure:

holidayplanner/
├── agents/
│ ├── input_agent.py
│ ├── destination_agent.py
│ ├── weather_agent.py
│ ├── budget_agent.py
│ ├── itinerary_agent.py
│ ├── result_agent.py
│ └── metrics_agent.py
├── tools/
│ ├── groq_tool.py
│ ├── yelp_tool.py
│ ├── huggingface_tool.py
│ └── weather_tool.py
├── orchestration/
│ ├── langgraph_flow.py
│ └── graph_visualizer.py
├── data/
│ └── graphs/graph_flow.png
├── logs/
│ └── agent_logs.txt
├── config/
│ ├── settings.py
│ └── constants.py
├── tests/
├── .env.example
├── requirements.txt
├── main.py
├── README.md
└── LICENSE

Experiments:

Experiments were conducted to validate tool reliability, agent cooperation, and consistency.

Weather Accuracy Test:

Checked responses for 5 global cities
Verified temperature, condition codes, and timeliness
Result: 98% consistency with OpenWeather dashboard.

Yelp API Relevance Test:

Queried restaurants, parks, museums
Manual comparison with Yelp’s website
Relevance score: 92%

Budget Constraint Test:

Purpose: To evaluate how well the Budget Agent approximates travel costs based on user input.
Procedure: Ran multiple destinations with varying durations and travel types. Compared AI-estimated budgets with real-world averages from travel websites.
Findings: Deviation remained within ±12% of average travel costs. Budget suggestions adjusted dynamically based on duration and location type.
Outcome: ✅ Acceptable accuracy for prototype-level system.

Agent Coordination Test:

20 end-to-end workflow runs
All runs completed successfully
Average latency reduced using Groq

Results:

The system was able to generate coherent itineraries within 3–6 seconds. Adjust activities due to weather (rain/snow alerts). It produce structured JSON compatible with downstream apps that maintain stable multi-agent communication without deadlocks and provide meaningful budget adaptive recommendations.

####Sample Output (Shortened):

{
  "destination": "Paris",
  "weather_summary": "Mild, light rain on Day 3",
  "budget_plan": {
    "total": 1200,
    "accommodation": 450,
    "food": 300,
    "activities": 250
  },
  "itinerary": [
    {"day": 1, "plan": "Eiffel Tower, Seine cruise"},
    {"day": 2, "plan": "Louvre + Old Town walk"}
  ]
}

Conclusion:

Travel Mate demonstrates how multi-agent architectures can simplify real-world workflows by automating research, reasoning, and planning. By combining tool-augmented LLMs with robust orchestration and reliable APIs, the system delivers personalized travel itineraries with professional-level accuracy. Its modular design and production-ready structure make it suitable for future scaling, deployment, and extension into recommendation engines, chat interfaces, or mobile apps.

Prerequisites & Requirements:

System:

Python 3.10+ (tested on 3.12)
Internet access (for external APIs)

Required API keys:

# API keys required 
OPENWEATHER_API_KEY (OpenWeather)
YELP_API_KEY (Yelp Fusion)
HUGGINGFACE_API_KEY (Hugging Face Inference)
GROQ_API_KEY (optional, Groq)

Libraries install via:

# Required packages include requests, python-dotenv, pytest, langgraph and any LLM client

pip install requests python-dotenv pytest langgraph groq

Files:

.env (private, must be in .gitignore) with API keys
.env.example included in repo to demonstrate required keys (no real keys)

graph_flow.png generated by orchestration/graph_visualizer.py and stored in data/graphs/

Setup Instructions:

Step 1 – Clone the Repository:

# git clone 
https://github.com/yourusername/holidayplanner.git
cd holidayplanner

Step 2 – Create Environment:

python -m venv venv
source venv/bin/activate   # Windows: venv\Scripts\activate
pip install -r requirements.txt

Step 3 – Create .env File

Use .env.example as reference:

OPENWEATHER_API_KEY=
YELP_API_KEY=
GROQ_API_KEY=
HUGGINGFACE_API_KEY=
DEFAULT_CITY=Paris

Step 4 – Run the System:

python main.py

License:

Please follow the code of conduct. This repo uses the MIT License.

Author:

Asma Rahman