Certifiedunder the Production-Grade Agentic System module in the Agentic AI In Production program.This project introduces a Production-Ready AI Travel Planner built using LangGraph, demonstrating how multi-agent systems can be orchestrated to generate personalized travel itineraries through specialized planning agents and external tools.
Unlike traditional travel assistants that rely on a single LLM call, this application adopts an agentic architecture, where different components collaborate to solve specific tasks including itinerary planning, weather retrieval, attraction discovery, accommodation recommendations, and budget estimation.
The project also focuses on production-readiness, integrating runtime guardrails, automated testing, observability with LangSmith, fault tolerance, structured logging, metrics instrumentation, and an interactive Streamlit interface.
Planning a trip typically requires gathering information from multiple sources such as weather services, tourist attractions, accommodation recommendations, and budget estimation.
Traditional LLM-based assistants often:
The objective of this project is to design a production-grade multi-agent travel planner capable of:
Unlike traditional chatbot implementations that rely on a single LLM call, this project adopts a multi-agent architecture using LangGraph.
The workflow begins with a Planner Agent, which interprets the user's natural language request and extracts structured travel information including destination, trip duration, budget, and interests. This structured state is then passed through a sequence of specialized tool nodes responsible for gathering additional information before a second LLM generates the final itinerary.
The workflow consists of the following components:
| Component | Responsibility |
|---|---|
| Planner Agent | Extracts structured travel information from natural language |
| Weather Tool | Retrieves live weather using OpenWeather API |
| Attractions Tool | Searches nearby attractions using OpenStreetMap |
| Stay Recommendation Tool | Suggests suitable accommodation areas |
| Budget Tool | Estimates overall trip expenses |
| Itinerary Agent | Generates the final day-by-day travel itinerary |
| Streamlit UI | Interactive user interface |
| LangSmith | Execution tracing and observability |
The Planner Agent is responsible for converting free-form natural language into structured JSON that can be consumed by downstream nodes.
Rather than manually parsing user input, the LLM is instructed to return a strict JSON schema, simplifying orchestration throughout the graph.
This approach separates intent understanding from business logic, making the workflow easier to extend with additional tools in the future.
LangGraph orchestrates the execution of each specialized component.
Instead of one monolithic prompt, each node performs a dedicated task before passing its output to the next node.
This modular workflow improves maintainability while enabling future extensions such as hotel search, flight booking, restaurant recommendations, and travel advisories without redesigning the overall architecture.
The project integrates multiple external services to provide real-time contextual information.
Weather Retrieval
Current weather conditions are retrieved using the OpenWeather API.
Attraction Discovery
Nearby attractions are discovered using the OpenStreetMap Nominatim API.
Additional tools estimate travel budgets and recommend suitable accommodation areas based on user preferences, enriching the final itinerary with practical recommendations.
After all tool outputs are collected, the Itinerary Agent combines the retrieved information into a detailed travel plan.
The LLM receives:
This separation between planning, tool execution, and itinerary generation results in a more modular and explainable agentic workflow.
Beyond itinerary generation, this project incorporates several production-oriented engineering practices that improve reliability, maintainability, and observability.
User inputs are validated before the workflow begins to prevent unsafe or invalid requests from reaching the LLM. The guardrails module checks user prompts and blocks requests that violate predefined safety rules. This reduces unnecessary LLM calls while improving system robustness.
The application includes Pytest-based unit tests to verify critical components independently.
The test suite validates:
Automated testing helps ensure that future code changes do not unintentionally break existing functionality.
To improve debugging and production monitoring, the application integrates LangSmith.
Every LLM invocation and tool execution is automatically traced, allowing developers to inspect:
These traces significantly simplify debugging and performance analysis.
The project uses Python's logging framework to capture application events throughout execution.
Examples include:
Structured logs improve troubleshooting and provide operational visibility during runtime.
Custom OpenTelemetry counters are used to track key application activities including:
These metrics provide insight into application usage and can be integrated with monitoring platforms for production deployments.
External APIs are inherently unreliable due to network issues or temporary service failures.
To improve resilience, a reusable retry decorator was implemented.
The decorator automatically retries failed requests before returning an error, improving reliability without complicating the core business logic.
The project includes a Streamlit-based web interface, allowing users to interact with the travel planner without using the command line.
Users simply enter their travel requirements and receive a personalized itinerary within seconds.
This project demonstrates how production-ready agentic AI systems can orchestrate multiple specialized tools to solve real-world planning problems. While the current implementation focuses on travel planning, the same architecture can be adapted to numerous enterprise use cases.
Some practical applications include:
The application is packaged with an interactive Streamlit interface, allowing users to describe their travel requirements using natural language and receive a personalized itinerary generated through the LangGraph workflow.
The project also includes LangSmith tracing, providing complete visibility into agent execution, LLM interactions, tool calls, and workflow latency for easier debugging and monitoring.
Streamlit User Interface
LangSmith Execution Trace
Application Execution
The terminal logs demonstrate the execution flow, including planner invocation, external API calls, logging, and itinerary generation.
Automated Testing
Critical application components are validated using Pytest to ensure consistent behavior across future code changes.
The complete source code for this Production-Ready AI Travel Planner is available on GitHub.
The repository includes:
GitHub Repository
The project can be cloned and executed locally by following the setup instructions provided in the repository README.
This project demonstrates how LangGraph can be used to build a production-ready multi-agent AI application by orchestrating specialized agents and external tools within a structured workflow.
Beyond generating personalized travel itineraries, the application incorporates several software engineering practices essential for deploying AI systems in production, including runtime guardrails, automated testing, structured logging, observability with LangSmith, metrics instrumentation, fault tolerance, and an interactive Streamlit interface.
The modular architecture enables new tools and agents to be integrated with minimal changes, making the solution scalable and extensible for more advanced travel planning capabilities such as hotel booking, flight recommendations, restaurant discovery, and travel advisory services.
Overall, this project showcases how modern agentic AI frameworks can move beyond simple chatbot interactions to deliver reliable, observable, and maintainable AI systems suitable for real-world deployment.