Abstract:

Overview:
HolidayPlanner is a modular, agentic AI system that automates the entire travel-planning workflow from user preferences to itinerary creation by using LangGraph-based orchestration, FastAPI, and a Streamlit UI.
This publication represents the Production-Ready System (Module 3), integrating agents, logging, observability, containerization, and deployment on Railway.

Problem Statement:

Travel planning is tedious users juggle weather checks, cost estimates, activities, and hotel searches. Existing tools are either generic or static.

Goal: Build a fully automated, intelligent planner that adapts to user goals, budgets, and recommended places to visit in real-time through a network of autonomous agents.

System Architecture:

HolidayPlanner is built as a multi-agent system using LangGraph for orchestration. Each agent performs a specialized task and passes data downstream.

• Core Components:

• Agents:
  🧍‍♀️ UserInputAgent: Gathers user preferences such as budget, duration, and interests.
  🌍 DestinationAgent: Suggests travel destinations based on user input and external APIs (Yelp/OpenWeather).
  ☁️ WeatherAgent: Retrieves real-time weather forecasts using the OpenWeather API.
  📅 ItineraryAgent: Builds a detailed itinerary from destination and weather data.
  💰 BudgetAgent: Calculates expected travel costs and ensures they stay within the user’s budget.
  🧾 ResultAggregator: Combines all outputs into a final summary report.

• Orchestration Layer:
  The agents are connected in a LangGraph workflow (orchestration/langgraph_flow.py).
  Data flows sequentially across agents.
  Execution is logged and monitored using MetricsTracker.
  Architecture Diagram

Related Work:

• Workflow Orchestration:
  Implemented via LangGraph, connecting agents as nodes in a directed flow.
  Data and decisions propagate forward automatically.
  Execution metadata logged through a centralized MetricsTracker.
  Visualization is stored by flow diagram in data/graphs/holiday_planner_flow.png using NetworkX + Matplotlib.

• Technical Stack:
  Backend uses FastAPI, LangGraph
  UI uses Streamlit
  Deployment by Railway
  Monitoring & Logging performed by Python logging, custom metrics_tool.py
  APIs are monitored by OpenWeather, Yelp (via MCPClient)

• Production-Ready Enhancements:
  Dockerized setup with Dockerfile.
  Modular directory structure for agents, tools, and orchestration
  Metrics & Logs stored in /data/metrics and /logs
  Custom error handling in each agent
  Secure API key management via .env
  FastAPI backend with /plan endpoint for programmatic access
  Streamlit UI for user-friendly interaction
  Railway deployment-ready configuration

Guardrails & Safety Layer:

HolidayPlanner includes multiple layers of guardrails to ensure stability, security, and ethical data usage.

• Input Validation User input (budget, duration, location) is sanitized and type-checked before processing.
• API Key Management Environment variables managed through .env (never hard-coded).
• Timeout Handling Each API request includes timeout and retry logic.
• Exception Guard All agents wrapped in try/except blocks; errors logged, not propagated.
• Response Safety Itinerary outputs are filtered for language safety and factual consistency.
• Data Privacy No personally identifiable information is stored.
• Monitoring Logs and metrics provide full transparency into execution flow.

Evaluation:

Test Setup:
Executed multiple travel scenarios (Tokyo, Jeddah, Paris) under varied budgets and durations.
Metric Description Result

• Workflow Completion All agents executed successfully end-to-end. 100 %
• Average Runtime Time from input to itinerary output. 3–5 s
• Logs & Metrics Generated automatically under /logs and /data/metrics. ✅
• Output Accuracy Destination and itinerary relevance. ~92 %
• API Reliability Weather + Yelp data retrieval rate. 100 %
• Error Recovery Graceful fallback for failed API calls. ✅ Implemented

Testing Summary:

All core components of the HolidayPlanner – Production Ready System were tested using pytest under Python 3.12.7. The goal was to ensure robustness, correctness, fairness, and consistent orchestration across agents, APIs, and tools.

1. End-to-End Tests:
   Command: pytest tests/test_end_to_end.py
   Result: test_api_plan_endpoint — PASSED in 2.81s
   Confirms that the full itinerary pipeline executes successfully from user input → API → itinerary generation → output storage.

2. API Layer Tests:
   Command: pytest tests/test_api.py
   Results: test_health_check — PASSED
   test_plan_route — PASSED
   Ensures that the FastAPI backend endpoints respond correctly and return valid structured JSON.
   Execution Time: 3.64s

3. Tool Utility Tests:
   Command: pytest tests/test_tools.py
   Results: test_mcp_client_call — PASSED
   test_metrics_tracker — PASSED
   Validates that internal utilities (MetricsTracker, MCP client, etc.) are logging, saving, and returning values as expected.
   Execution Time: 0.12s

4. Integration Tests:
   Command: pytest tests/test_integration.py
   Result: test_integration_agent_metrics — PASSED in 3.09s
   Confirms seamless interaction between agents, ensuring that metrics tracking and LangGraph orchestration work end-to-end.

5. Fairness and Diversity Tests:
   Command: pytest tests/test_fairness.py
   Results: test_budget_fairness[1000-budget] — PASSED
   test_budget_fairness[5000-mixed] — PASSED
   test_budget_fairness[10000-luxury] — PASSED
   test_destination_diversity — PASSED
   Confirms the AI agents produce balanced, unbiased itineraries across varying budgets and locations.
   Execution Time: 15.38s

6. Agent Workflow Tests:
   Command: pytest tests/test_agents.py -v
   Results: test_run_holiday_planner_valid — PASSED
   test_run_holiday_planner_invalid_budget — PASSED
   test_run_holiday_planner_zero_budget — PASSED
   Confirms that agent logic gracefully handles both valid and invalid input scenarios without breaking orchestration.
   Execution Time: 3.01s

Outcome:
All 13 tests passed successfully with zero critical issues.
The project demonstrates:
Full API and orchestration stability
Reliable metrics logging and fairness evaluation
Agent-level fault tolerance
End-to-end reproducibility

Deployment:

The syatem runs locally:
uvicorn api.main_api

--reload --host 127.0.0.1 --port 8000
streamlit run ui/app_streamlit.py

The system runs in a containerized environment:
docker build -t holidayplanner

.
docker run --rm -p 8501:8501 holidayplanner

For cloud deployment, push the repo to GitHub and connect it to Railway.app.

Railway Deployment:

For railway deployment follow thses simp
Push the repo to GitHub
Go to Railway.app
→ “New Project” → “Deploy from GitHub”
Add environment variables from .env
Railway auto-builds your Docker image
Access UI via Railway-generated URL

User Interface:

Streamlit UI features:
Input fields for destination, budget, and duration
Displays itinerary, weather, and cost summary
Integrated metrics summary and logs viewer

Results Summary:

Component Status:
✅ Agents pipeline execution Complete
✅ Graph visualization Generated
✅ Logs & metrics Stored
✅ Docker containerization Successful
✅ Railway deployment Ready
🚀 Overall system stability 100 % verified

Conclusion:

HolidayPlanner is a production-grade AI system demonstrating:
1.Modular agent-based design
2.Real-time data integration
3.Robust guardrails
4.Seamless observability
5.Fully containerized deployment

This project illustrates how LangGraph, FastAPI, and Streamlit can collaborate to create scalable, transparent, and safe AI automation systems for real-world use.