Upload folder using huggingface_hub

.env.name

@@ -0,0 +1,15 @@
+OPEN_API_KEY=""
+GROQ_API_KEY=""
+GOOGLE_API_KEY=""
+GPLACES_API_KEY=""  # https://console.cloud.google.com/ - create a project, enable google, and then generate the key
+FOURSQUARE_API_KEY=""
+TAVILAY_API_KEY="" # https://app.tavily.com/home - my Github login - It scraps the internet webpages.
+OPENWEATHER_API_KEY=""
+EXCHANGE_RATE_API_KEY="" # https://www.exchangerate-api.com/ - 2 week validatity on my yahooid/brosnia
+ALPHAVANTAGE_API_KEY="" # https://www.alphavantage.co/ - Free exchange rate for currency conversion. Also you can get current news or real-time stock data
+LANGSMITH_TRACING=true
+LANGSMITH_ENDPOINT="https://api.smith.langchain.com" # https://smith.langchain.com/ - login using google login
+LANGSMITH_API_KEY=""
+LANGSMITH_PROJECT="ai-trip-planner"
+
+##My Org: kube9t.com / Email: bibhup_mishra@yahoo.com or bm80177@gmail.com

.gitignore

@@ -0,0 +1,4 @@
+_venv
+.env
+ai_trip_planner.egg-info
+**/__pycache__

.hfignore

@@ -0,0 +1,5 @@
+*.bin
+*.sqlite3
+*.pdf
+*.png
+*.jpg

Dockerfile

@@ -0,0 +1,20 @@
+# Use a lightweight Python image
+FROM python:3.10-slim
+
+# Set working directory inside the container
+WORKDIR /app
+
+# Copy only requirements first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the HF Spaces default port
+EXPOSE 7860
+
+# Run Uvicorn on port 7860 (HF Spaces only exposes 7860)
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,12 @@
+---
+title: AI Trip Planner API
+emoji: 🌍
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+---
+
+# AI Trip Planner API
+
+Docker-based API for AI-powered trip planning

agent/agentic_workflow.py

@@ -0,0 +1,83 @@
+
+from utils.model_loader import ModelLoader
+from prompt_library.prompt import SYSTEM_PROMPT
+from langgraph.graph import StateGraph, MessagesState, END, START
+from langgraph.graph.message import add_messages # Is reducer function that just aggregrates the messages.
+from langgraph.prebuilt import ToolNode, tools_condition
+from tools.weather_info_tool import WeatherInfoTool
+from tools.place_search_tool import PlaceSearchTool
+from tools.expense_calculator_tool import CalculatorTool
+from tools.currency_conversion_tool import CurrencyConverterTool
+from typing import TypedDict, Sequence, Optional, Annotated
+from langchain_core.messages import BaseMessage, HumanMessage
+from datetime import datetime
+
+class AgentState(TypedDict):
+    # messages is a list (or other sequence) of BaseMessage objects, and it has extra metadata attached to it: add_messages
+    ## Sequence is a type hint that represents any ordered, iterable collection of items — like lists, tuples, or strings 
+    ## Annotated type lets you attach metadata to a type. It's not used by Python itself, but frameworks (like LangGraph, Pydantic, FastAPI) can use it.
+    messages: Annotated[Sequence[BaseMessage], add_messages]
+
+class GraphBuilder():
+    def __init__(self,model_provider: str = "openai"):
+        self.model_loader = ModelLoader(model_provider=model_provider)
+        self.llm = self.model_loader.load_llm()
+        
+        self.tools = []
+        
+        self.weather_tools = WeatherInfoTool()
+        self.place_search_tools = PlaceSearchTool()
+        self.calculator_tools = CalculatorTool()
+        self.currency_converter_tools = CurrencyConverterTool()
+        
+        self.tools.extend([* self.weather_tools.weather_tool_list, 
+                           * self.place_search_tools.place_search_tool_list,
+                           * self.calculator_tools.calculator_tool_list,
+                           * self.currency_converter_tools.currency_converter_tool_list])
+        
+        self.llm_with_tools = self.llm.bind_tools(tools=self.tools)
+        
+        self.graph = None
+        
+        self.system_prompt = SYSTEM_PROMPT
+    
+    
+    def agent_function(self,state: MessagesState):
+        """Main agent function"""
+        user_question = state["messages"]
+        input_question = [self.system_prompt] + user_question
+        # with mlflow.start_run(run_name="genai-trip-planner-llm-call", nested=True):
+        response = self.llm_with_tools.invoke(input_question)
+        return {"messages": [response]}
+    
+    def should_continue(self, state: AgentState) -> AgentState:
+        messages = state['messages']
+        last_message = messages[-1]
+        if not last_message.tool_calls:
+            return "end"
+        else:
+            return "continue"
+    
+    def build_graph(self):
+        
+        graph_builder=StateGraph(MessagesState)
+        graph_builder.add_node("agent", self.agent_function)
+        graph_builder.add_node("tools", ToolNode(tools=self.tools))
+        graph_builder.add_edge(START,"agent")
+        # graph_builder.add_conditional_edges("agent",tools_condition)
+        graph_builder.add_conditional_edges(
+            source="agent",
+            path=self.should_continue,
+            path_map={
+                # Edge: Node
+                "end": END,
+                "continue": "tools"
+            }
+        )
+        graph_builder.add_edge("tools","agent")
+        # graph_builder.add_edge("agent",END)
+        self.graph = graph_builder.compile()
+        return self.graph
+        
+    def __call__(self):
+        return self.build_graph()

agent/agentic_workflownew.py

@@ -0,0 +1,138 @@
+import os
+import asyncio
+from datetime import datetime
+from typing import TypedDict, Sequence, Optional, Annotated, List
+
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessageChunk
+from langchain_core.runnables import RunnableConfig
+
+from langgraph.graph import StateGraph, MessagesState, END, START
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from utils.model_loader import ModelLoader
+from prompt_library.prompt import SYSTEM_PROMPT
+
+from tools.weather_info_tool import WeatherInfoTool
+from tools.place_search_tool import PlaceSearchTool
+from tools.expense_calculator_tool import CalculatorTool
+from tools.currency_conversion_tool import CurrencyConverterTool
+
+
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[BaseMessage], add_messages]
+
+
+class GraphBuilder:
+    def __init__(self, model_provider: str = "openai"):
+        self.model_loader = ModelLoader(model_provider=model_provider)
+        self.llm = self.model_loader.load_llm()
+
+        self.tools = []
+
+        # Load tools
+        self.weather_tools = WeatherInfoTool()
+        self.place_search_tools = PlaceSearchTool()
+        self.calculator_tools = CalculatorTool()
+        self.currency_converter_tools = CurrencyConverterTool()
+
+        # Register tools
+        self.tools.extend([
+            *self.weather_tools.weather_tool_list,
+            *self.place_search_tools.place_search_tool_list,
+            *self.calculator_tools.calculator_tool_list,
+            *self.currency_converter_tools.currency_converter_tool_list
+        ])
+
+        # Bind LLM with tools
+        self.llm_with_tools = self.llm.bind_tools(tools=self.tools)
+
+        self.graph = None
+        self.system_prompt = SYSTEM_PROMPT
+
+    async def async_agent_function(self, state: MessagesState):
+        """
+        Async agent function that streams the LLM response.
+        """
+        user_question = state["messages"]
+        input_question = [self.system_prompt] + user_question
+
+        full_response = ""
+        async for chunk in self.llm_with_tools.astream(input_question):
+            if isinstance(chunk, AIMessageChunk):
+                content = chunk.content or ""
+                full_response += content
+                print(f"[LLM] {content}", end="", flush=True)
+
+        print()  # newline after full message
+        return {"messages": [chunk]}
+
+    def should_continue(self, state: AgentState) -> str:
+        """
+        Decide whether to continue to tools or end the graph.
+        """
+        messages = state['messages']
+        last_message = messages[-1]
+        if not last_message.tool_calls:
+            return "end"
+        else:
+            return "continue"
+
+    def build_graph(self):
+        """
+        Build the LangGraph state machine with streaming.
+        """
+        graph_builder = StateGraph(MessagesState)
+
+        # Add nodes
+        graph_builder.add_node("agent", self.async_agent_function)
+        graph_builder.add_node("tools", ToolNode(tools=self.tools))
+
+        # Add transitions
+        graph_builder.add_edge(START, "agent")
+        graph_builder.add_conditional_edges(
+            source="agent",
+            path=self.should_continue,
+            path_map={
+                "end": END,
+                "continue": "tools"
+            }
+        )
+        graph_builder.add_edge("tools", "agent")
+
+        self.graph = graph_builder.compile()
+        return self.graph
+
+    async def stream(self, user_input: str):
+        """
+        Stream the response end-to-end from graph.
+        """
+        if self.graph is None:
+            self.build_graph()
+
+        print(f"[User] {user_input}\n")
+        async for event in self.graph.astream(
+            {"messages": [HumanMessage(content=user_input)]},
+            config=RunnableConfig()
+        ):
+            if 'messages' in event:
+                for msg in event['messages']:
+                    print(f"\n[Tool/Final] {msg.content}\n")
+
+
+    async def __call__(self, user_input: str) -> str:
+        if self.graph is None:
+            self.build_graph()
+
+        final_output = ""
+
+        async for event in self.graph.astream(
+            {"messages": [HumanMessage(content=user_input)]},
+            config=RunnableConfig()
+        ):
+            if "messages" in event:
+                for msg in event["messages"]:
+                    final_output = msg.content  # only keep last
+                    print(f"[Tool/LLM] {msg.content}")
+
+        return final_output

app/Dockerfile

@@ -0,0 +1,19 @@
+# Use lightweight Python base image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy app code and requirements
+COPY requirements.txt .
+COPY . .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose HF Spaces port
+EXPOSE 7860
+
+# Run Streamlit
+# CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.headless=true"]
+CMD ["streamlit", "run", "app/streamlit_app.py", "--server.port=7860", "--server.headless=true"]  # IGNORE

app/README.md

@@ -0,0 +1,20 @@
+---
+title: Trip Advisor App
+emoji: 🚀
+colorFrom: red
+colorTo: red
+sdk: docker
+app_port: 8501
+tags:
+- streamlit
+pinned: false
+short_description: AI trip advisor app
+license: mit
+---
+
+# Welcome to Streamlit!
+
+Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+
+If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
+forums](https://discuss.streamlit.io).

app/requirements.txt

@@ -0,0 +1,4 @@
+altair
+pandas
+streamlit
+requests

app/streamlit_app.py

@@ -0,0 +1,83 @@
+import streamlit as st
+import requests
+import datetime
+
+BASE_URL = "https://huggingface.co/spaces/mishrabp/trip-advisor-api"   # Backend endpoint
+
+# Set up Streamlit page configuration
+st.set_page_config(
+    page_title="Travel Planner Agentic Application",
+    page_icon="🌍",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ---------------------------
+# Sidebar Navigation
+# ---------------------------
+with st.sidebar:
+    st.image("https://cdn-icons-png.flaticon.com/512/201/201623.png", width=80)
+    st.title("🌍 Travel Planner")
+    st.markdown("Plan your trips effortlessly with AI ✈️")
+    st.markdown("---")
+    st.subheader("Navigation")
+    st.page_link("https://openai.com", label="🏠 Home", disabled=True)
+    st.page_link("https://openai.com", label="🧳 My Trips", disabled=True)
+    st.page_link("https://openai.com", label="⚙️ Settings", disabled=True)
+    st.markdown("---")
+    st.caption("Powered by Kube9t's Travel Agent AI")
+
+# ---------------------------
+# Hero Section
+# ---------------------------
+st.markdown(
+    """
+    <div style="background-color:#0c2a45; padding:2rem 1rem; border-radius:10px;">
+        <h1 style="color:white; text-align:center;">🌍 Travel Planner Agentic Application</h1>
+        <p style="color:white; text-align:center; font-size:1.2rem;">
+            Let me help you design your next perfect trip — just tell me where you want to go!
+        </p>
+    </div>
+    """,
+    unsafe_allow_html=True
+)
+
+st.markdown("### ✨ What can I help you plan today?")
+
+# Initialize chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Chat input form
+with st.form(key="query_form", clear_on_submit=True):
+    user_input = st.text_input("Ask me something like: 'Plan a 7 days trip to Washnigton-DC, NewYork, and Niagra.'")
+    submit_button = st.form_submit_button("Send")
+
+# Handle form submission
+if submit_button and user_input.strip():
+    try:
+        with st.spinner("🧠 Thinking..."):
+            payload = {"question": user_input}
+            response = requests.post(f"{BASE_URL}/query", json=payload)
+
+        if response.status_code == 200:
+            answer = response.json().get("answer", "No answer returned.")
+            markdown_content = f"""
+### 🗺️ AI-Generated Travel Plan  
+**Generated:** {datetime.datetime.now().strftime('%Y-%m-%d at %H:%M')}  
+**Created by:** Kube9t's Travel Agent
+
+---
+
+{answer}
+
+---
+
+📝 *Please double-check all travel details, costs, and dates before booking.*
+"""
+            st.markdown(markdown_content)
+        else:
+            st.error("❌ Bot failed to respond: " + response.text)
+
+    except Exception as e:
+        st.error(f"⚠️ Something went wrong: {e}")

config/config.yaml

@@ -0,0 +1,12 @@
+llm:
+  openai:
+    provider: "openai"
+    model_name: "gpt-4o-mini"
+  groq:
+    provider: "groq"
+    model_name: "llama-3.1-70b-versatile"
+  azureopenai:
+    provider: "azureopenai"
+    model_name: "gpt-4o"
+    endpoint: "https://srepoc-ai-services.openai.azure.com/"
+    api_version: "2025-01-01-preview"

logger/decorators.py

@@ -0,0 +1,13 @@
+import functools
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def log_entry(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        arg_list = [repr(a) for a in args] + [f"{k}={v!r}" for k, v in kwargs.items()]
+        logger.info(f"➡️ Entering: {func.__name__}({', '.join(arg_list)})")
+        return func(*args, **kwargs)
+    return wrapper

main.py

@@ -0,0 +1,49 @@
+import os
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from agent.agentic_workflow import GraphBuilder
+from fastapi.responses import JSONResponse
+from dotenv import load_dotenv
+from pydantic import BaseModel
+import datetime
+from typing import List
+
+load_dotenv()
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust for prod
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class QueryRequest(BaseModel):
+    question: str
+
+@app.post("/query")
+async def query_travel_agent(query: QueryRequest):
+    try:
+        graph_agent = GraphBuilder(model_provider="groq")
+
+        # Collect streamed output
+        streamed_response: List[str] = []
+
+        async def capture_stream():
+            async for event in graph_agent.graph.astream(
+                {"messages": [query.question]},
+            ):
+                if "messages" in event:
+                    for msg in event["messages"]:
+                        streamed_response.append(msg.content)
+
+        # Ensure the graph is built
+        graph_agent.build_graph()
+        await capture_stream()
+
+        return {"answer": streamed_response[-1] if streamed_response else "No response received."}
+
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})

mainnew.py

@@ -0,0 +1,50 @@
+import os
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from agent.agentic_workflow import GraphBuilder
+from utils.save_to_document import save_document
+from fastapi.responses import JSONResponse
+import datetime
+from dotenv import load_dotenv
+from pydantic import BaseModel
+load_dotenv()
+
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # set specific origins in prod
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+class QueryRequest(BaseModel):
+    question: str
+
+@app.post("/query")
+async def query_travel_agent(query:QueryRequest):
+    try:
+        print(query)
+        graph = GraphBuilder(model_provider="groq")
+        react_agent=graph() #it creates the __call__() method in the class
+        #react_agent = graph.build_graph()
+
+        png_graph = react_agent.get_graph().draw_mermaid_png()
+        with open("my_graph.png", "wb") as f:
+            f.write(png_graph)
+
+        print(f"Graph saved as 'my_graph.png' in {os.getcwd()}")
+        # Assuming request is a pydantic object like: {"question": "your text"}
+        messages={"messages": [query.question]}
+        output = react_agent.invoke(messages)
+
+        # If result is dict with messages:
+        if isinstance(output, dict) and "messages" in output:
+            final_output = output["messages"][-1].content  # Last AI response
+        else:
+            final_output = str(output)
+        
+        return {"answer": final_output}
+    except Exception as e:
+        return JSONResponse(status_code=500, content={"error": str(e)})

prompt_library/prompt.py

@@ -0,0 +1,56 @@
+from langchain_core.messages import SystemMessage
+
+# SYSTEM_PROMPT = SystemMessage(
+#     content="""You are a helpful AI Travel Agent and Expense Planner. 
+#     You help users plan trips to any place worldwide with real-time data from internet.
+    
+#     Provide complete, comprehensive and a detailed travel plan. Always try to provide two
+#     plans, one for the generic tourist places, another for more off-beat locations situated
+#     in and around the requested place.  
+#     Give full information immediately including:
+#     - Complete day-by-day itinerary
+#     - Recommended hotels for boarding along with approx per night cost
+#     - Places of attractions around the place with details
+#     - Recommended restaurants with prices around the place
+#     - Activities around the place with details
+#     - Mode of transportations available in the place with details
+#     - Detailed cost breakdown
+#     - Per Day expense budget approximately
+#     - Weather details
+    
+#     Use the available tools first to gather information and make detailed cost breakdowns before you make any assumptions.
+#     Provide everything in one comprehensive response formatted in clean Markdown.
+
+#     Note: You are travel planner. If you receive unrelevant questions, politely say that you can not assist.
+#     """
+# )
+
+SYSTEM_PROMPT = SystemMessage(
+    content = """
+        You are a helpful and intelligent AI Travel Agent and Expense Planner.
+
+        Your job is to plan trips to any location worldwide by using real-time information through tools provided to you.
+
+        You must follow these steps:
+        1. **Understand the user's request**: Read the user's question carefully to determine their travel needs.
+        2. **Use tools to gather data**: Call the relevant tools to fetch real-time information about weather, attractions, costs, etc.
+        3. **Plan the trip**: Create a detailed travel plan based on the gathered data.
+        4. **Respond with a comprehensive plan**: Provide a complete travel itinerary in Markdown format.
+
+        Make sure your plan includes:
+        - 📅 Day-by-day itinerary
+        - 🏨 Recommended hotels with approximate cost per night
+        - 🗺️ Attractions with descriptions
+        - 🍽️ Recommended restaurants and pricing
+        - 🛶 Activities with timing and pricing
+        - 🚗 Transportation options available
+        - 🌤️ Weather details (use weather tool)
+        - 💰 Approximate per-day and total cost breakdown
+
+        ### Rules:
+        - If the user asks a travel-related question, you MUST first call the relevant tools to gather data.
+        - If the tools do not return results, only then use prior knowledge.
+        - If the question is unrelated to travel, respond politely that you can’t help with that.
+
+        """
+)

pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "ai-trip-planner"
+version = "0.1.0"
+description = "A learning project that uses AI for Trip Planning."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []

requirements-local.txt

@@ -0,0 +1,20 @@
+langchain
+langgraph
+langchain-community
+langchain-experimental
+langchain-google-community
+langchain-google-community[places]
+langchain_tavily
+langchain_groq
+langchain_openai
+fastapi
+python-dotenv
+streamlit
+uvicorn
+httpx
+requests
+azure-identity
+mlflow
+gradio
+
+-e .

requirements.txt

@@ -0,0 +1,18 @@
+langchain
+langgraph
+langchain-community
+langchain-experimental
+langchain-google-community
+langchain-google-community[places]
+langchain_tavily
+langchain_groq
+langchain_openai
+fastapi
+python-dotenv
+streamlit
+uvicorn
+httpx
+requests
+azure-identity
+mlflow
+gradio

setup.py

@@ -0,0 +1,37 @@
+from setuptools import find_packages,setup
+from typing import List
+
+def get_requirements()->List[str]:
+    """
+    This function will return list of requirements
+    """
+    requirement_list:List[str] = []
+    
+    try:
+        # Open and read the requirements.txt file
+        with open('requirements.txt', 'r') as file:
+            # Read lines from the file
+            lines = file.readlines()
+            # Process each line
+            for line in lines:
+                # Strip whitespace and newline characters
+                requirement = line.strip()
+                # Ignore empty lines and -e .
+                if requirement and requirement != '-e .':
+                    requirement_list.append(requirement)
+    except FileNotFoundError:
+        print("requirements.txt file not found.")
+
+    
+        
+    return requirement_list
+print(get_requirements())
+
+setup(
+    name="AI-TRAVEL-PLANNER",
+    version="0.0.1",
+    author="Bibhu Mishra",
+    author_email="bm80177@gmail.com",
+    packages = find_packages(),
+    install_requires=get_requirements()
+)

tools/arthmatic_op_tool.py

@@ -0,0 +1,66 @@
+import os
+from dotenv import load_dotenv
+load_dotenv()
+from langchain.tools import tool
+from langchain_community.utilities.alpha_vantage import AlphaVantageAPIWrapper
+from logger.decorators import log_entry
+
+@tool
+@log_entry
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two integers.
+
+    This tool takes two integer values and returns their product.
+
+    Args:
+        a (int): The first integer.
+        b (int): The second integer.
+
+    Returns:
+        int: The product of `a` and `b`.
+    """
+    print('Entered into multiply().')
+    return a * b
+
+@tool
+@log_entry
+def add(a: int, b: int) -> int:
+    """
+    Add two integers.
+
+    This tool takes two integer values and returns their sum.
+
+    Args:
+        a (int): The first integer.
+        b (int): The second integer.
+
+    Returns:
+        int: The sum of `a` and `b`.
+    """
+    print('Entered into add().')
+    return a + b
+
+@tool
+@log_entry
+def currency_converter(from_curr: str, to_curr: str, value: float) -> float:
+    """
+    Convert a currency value from one currency to another using real-time exchange rates.
+
+    This tool uses the AlphaVantage API to fetch real-time exchange rates and converts 
+    the given value from `from_curr` to `to_curr`.
+
+    Args:
+        from_curr (str): The currency code to convert from (e.g., "USD").
+        to_curr (str): The currency code to convert to (e.g., "EUR").
+        value (float): The numeric amount in the `from_curr` currency.
+
+    Returns:
+        float: The equivalent amount in `to_curr` currency based on the current exchange rate.
+    """
+    print('Entered into currency_converter().')
+    os.environ["ALPHAVANTAGE_API_KEY"] = os.getenv('ALPHAVANTAGE_API_KEY')
+    alpha_vantage = AlphaVantageAPIWrapper()
+    response = alpha_vantage._get_exchange_rate(from_curr, to_curr)
+    exchange_rate = response['Realtime Currency Exchange Rate']['5. Exchange Rate']
+    return value * float(exchange_rate)

tools/currency_conversion_tool.py

@@ -0,0 +1,53 @@
+import os
+from typing import List
+from dotenv import load_dotenv
+from langchain.tools import tool
+from logger.decorators import log_entry
+from utils.currency_converter import CurrencyConverter
+
+class CurrencyConverterTool:
+    """
+    A wrapper class that defines a LangChain-compatible tool for converting currencies
+    using a custom CurrencyConverter service.
+
+    Attributes:
+        api_key (str): API key for the currency conversion service.
+        currency_service (CurrencyConverter): Instance of the currency conversion service.
+        currency_converter_tool_list (List): List of registered LangChain tools.
+    """
+
+    def __init__(self):
+        """
+        Initialize the CurrencyConverterTool with API credentials and tool setup.
+        """
+        load_dotenv()
+        self.api_key = os.environ.get("EXCHANGE_RATE_API_KEY")
+        self.currency_service = CurrencyConverter(self.api_key)
+        self.currency_converter_tool_list = self._setup_tools()
+
+    def _setup_tools(self) -> List:
+        """
+        Define and register the currency conversion tool.
+
+        Returns:
+            List: A list containing the currency conversion tool function.
+        """
+
+        @tool
+        @log_entry
+        def convert_currency(amount: float, from_currency: str, to_currency: str) -> float:
+            """
+            Convert an amount from one currency to another using real-time exchange rates.
+
+            Args:
+                amount (float): The amount of money to convert.
+                from_currency (str): The currency code to convert from (e.g., "USD").
+                to_currency (str): The currency code to convert to (e.g., "EUR").
+
+            Returns:
+                float: The equivalent amount in the target currency.
+            """
+            print('Entered into convert_currency().')
+            return self.currency_service.convert(amount, from_currency, to_currency)
+
+        return [convert_currency]

tools/expense_calculator_tool.py

@@ -0,0 +1,76 @@
+from typing import List
+from langchain.tools import tool
+from logger.decorators import log_entry
+from utils.expense_calculator import Calculator
+
+class CalculatorTool:
+    """
+    A wrapper class for trip-related financial calculations using a custom Calculator utility.
+
+    This class exposes several LangChain-compatible tools for estimating hotel costs,
+    calculating total expenses, and determining daily budgets.
+    """
+
+    def __init__(self):
+        """
+        Initialize the CalculatorTool by creating an instance of Calculator and setting up tools.
+        """
+        self.calculator = Calculator()
+        self.calculator_tool_list = self._setup_tools()
+
+    def _setup_tools(self) -> List:
+        """
+        Define and register calculator tools related to trip planning.
+
+        Returns:
+            List: A list of LangChain tool functions for financial calculations.
+        """
+
+        @tool
+        @log_entry
+        def estimate_total_hotel_cost(price_per_night: str, total_days: float) -> float:
+            """
+            Estimate the total hotel cost for a trip.
+
+            Args:
+                price_per_night (str): Cost per night for the hotel stay (may include currency symbol).
+                total_days (float): Number of nights staying at the hotel.
+
+            Returns:
+                float: Total cost for the hotel stay.
+            """
+            print('Entered into estimate_total_hotel_cost().')
+            return self.calculator.multiply(price_per_night, total_days)
+
+        @tool
+        @log_entry
+        def calculate_total_expense(*costs: float) -> float:
+            """
+            Calculate the total trip expense by summing up individual cost items.
+
+            Args:
+                *costs (float): A variable number of expense values (e.g., hotel, food, transport).
+
+            Returns:
+                float: The total combined expense.
+            """
+            print('Entered into calculate_total_expense().')
+            return self.calculator.calculate_total(*costs)
+
+        @tool
+        @log_entry
+        def calculate_daily_expense_budget(total_cost: float, days: int) -> float:
+            """
+            Calculate the average daily budget for the trip.
+
+            Args:
+                total_cost (float): Total trip cost.
+                days (int): Number of days in the trip.
+
+            Returns:
+                float: Estimated daily budget.
+            """
+            print('Entered into calculate_daily_expense_budget().')
+            return self.calculator.calculate_daily_budget(total_cost, days)
+
+        return [estimate_total_hotel_cost, calculate_total_expense, calculate_daily_expense_budget]

tools/place_search_tool.py

@@ -0,0 +1,118 @@
+import os
+from typing import List
+from dotenv import load_dotenv
+from langchain.tools import tool
+from logger.decorators import log_entry
+from utils.place_info_search import GooglePlaceSearchTool, TavilyPlaceSearchTool
+
+class PlaceSearchTool:
+    """
+    A wrapper class that provides LangChain-compatible tools to search for
+    attractions, restaurants, activities, and transportation options in a given place.
+
+    It uses Google Places API primarily and falls back to Tavily search if needed.
+    """
+
+    def __init__(self):
+        """
+        Initialize the PlaceSearchTool with required API keys and setup tool functions.
+        """
+        load_dotenv()
+        self.google_api_key = os.environ.get("GPLACES_API_KEY")
+        self.google_places_search = GooglePlaceSearchTool(self.google_api_key)
+        self.tavily_search = TavilyPlaceSearchTool()
+        self.place_search_tool_list = self._setup_tools()
+
+    def _setup_tools(self) -> List:
+        """
+        Setup and register all LangChain-compatible place search tools.
+
+        Returns:
+            List: A list of tool functions that can be invoked via LangChain agents.
+        """
+
+        @tool
+        @log_entry
+        def search_attractions(place: str) -> str:
+            """
+            Search for popular attractions in a given place.
+
+            Args:
+                place (str): The name of the place (e.g., "New York").
+
+            Returns:
+                str: A list of suggested attractions retrieved from Google or Tavily.
+            """
+            print('Entered into search_attractions().')
+            try:
+                attraction_result = self.google_places_search.google_search_attractions(place)
+                if attraction_result:
+                    return f"Following are the attractions of {place} as suggested by Google: {attraction_result}"
+            except Exception as e:
+                tavily_result = self.tavily_search.tavily_search_attractions(place)
+                return f"Google cannot find the details due to {e}.\nFollowing are the attractions of {place}: {tavily_result}"
+
+        @tool
+        @log_entry
+        def search_restaurants(place: str) -> str:
+            """
+            Search for restaurants in a given place.
+
+            Args:
+                place (str): The name of the place (e.g., "San Francisco").
+
+            Returns:
+                str: A list of suggested restaurants retrieved from Google or Tavily.
+            """
+            print('Entered into search_restaurants().')
+            try:
+                restaurants_result = self.google_places_search.google_search_restaurants(place)
+                if restaurants_result:
+                    return f"Following are the restaurants of {place} as suggested by Google: {restaurants_result}"
+            except Exception as e:
+                tavily_result = self.tavily_search.tavily_search_restaurants(place)
+                return f"Google cannot find the details due to {e}.\nFollowing are the restaurants of {place}: {tavily_result}"
+
+        @tool
+        @log_entry
+        def search_activities(place: str) -> str:
+            """
+            Search for activities available in a given place.
+
+            Args:
+                place (str): The name of the place (e.g., "Chicago").
+
+            Returns:
+                str: A list of activities retrieved from Google or Tavily.
+            """
+            print('Entered into search_activities().')
+            try:
+                activities_result = self.google_places_search.google_search_activity(place)
+                if activities_result:
+                    return f"Following are the activities in and around {place} as suggested by Google: {activities_result}"
+            except Exception as e:
+                tavily_result = self.tavily_search.tavily_search_activity(place)
+                return f"Google cannot find the details due to {e}.\nFollowing are the activities of {place}: {tavily_result}"
+
+        @tool
+        @log_entry
+        def search_transportation(place: str) -> str:
+            """
+            Search for transportation options available in a given place.
+
+            Args:
+                place (str): The name of the place (e.g., "Los Angeles").
+
+            Returns:
+                str: A list of transportation modes retrieved from Google or Tavily.
+            """
+            print('Entered into search_transportation().')
+            try:
+                transport_result = self.google_places_search.google_search_transportation(place)
+                if transport_result:
+                    return f"Following are the modes of transportation available in {place} as suggested by Google: {transport_result}"
+            except Exception as e:
+                tavily_result = self.tavily_search.tavily_search_transportation(place)
+                return f"Google cannot find the details due to {e}.\nFollowing are the modes of transportation available in {place}: {tavily_result}"
+
+        return [search_attractions, search_restaurants, search_activities, search_transportation]

tools/weather_info_tool.py

@@ -0,0 +1,77 @@
+import os
+from typing import List
+from dotenv import load_dotenv
+from langchain.tools import tool
+from logger.decorators import log_entry
+from utils.weather_info import WeatherForecastTool
+
+class WeatherInfoTool:
+    """
+    A wrapper class for retrieving weather information using the OpenWeatherMap API.
+
+    This class provides LangChain-compatible tools to get current weather and weather forecasts
+    for a given city.
+    """
+
+    def __init__(self):
+        """
+        Initialize the WeatherInfoTool with API credentials and set up weather-related tools.
+        """
+        load_dotenv()
+        self.api_key = os.environ.get("OPENWEATHERMAP_API_KEY")
+        self.weather_service = WeatherForecastTool(self.api_key)
+        self.weather_tool_list = self._setup_tools()
+
+    def _setup_tools(self) -> List:
+        """
+        Define and register weather-related LangChain tool functions.
+
+        Returns:
+            List: A list of LangChain-compatible weather tool functions.
+        """
+
+        @tool
+        @log_entry
+        def get_current_weather(city: str) -> str:
+            """
+            Get the current weather information for a specified city.
+
+            Args:
+                city (str): The name of the city to get current weather data for.
+
+            Returns:
+                str: A string describing the current temperature and weather condition.
+            """
+            print('Entered into get_current_weather().')
+            weather_data = self.weather_service.get_current_weather(city)
+            if weather_data:
+                temp = weather_data.get('main', {}).get('temp', 'N/A')
+                desc = weather_data.get('weather', [{}])[0].get('description', 'N/A')
+                return f"Current weather in {city}: {temp}°C, {desc}"
+            return f"Could not fetch weather for {city}"
+
+        @tool
+        @log_entry
+        def get_weather_forecast(city: str) -> str:
+            """
+            Get the multi-day weather forecast for a specified city.
+
+            Args:
+                city (str): The name of the city to get the weather forecast for.
+
+            Returns:
+                str: A string listing daily temperatures and descriptions for upcoming forecasts.
+            """
+            print('Entered into get_weather_forecast().')
+            forecast_data = self.weather_service.get_forecast_weather(city)
+            if forecast_data and 'list' in forecast_data:
+                forecast_summary = []
+                for item in forecast_data['list']:
+                    date = item['dt_txt'].split(' ')[0]
+                    temp = item['main']['temp']
+                    desc = item['weather'][0]['description']
+                    forecast_summary.append(f"{date}: {temp}°C, {desc}")
+                return f"Weather forecast for {city}:\n" + "\n".join(forecast_summary)
+            return f"Could not fetch forecast for {city}"
+
+        return [get_current_weather, get_weather_forecast]

utils/config_loader.py

@@ -0,0 +1,8 @@
+import yaml
+import os
+
+def load_config(config_path: str = "config/config.yaml") -> dict:
+    with open(config_path, "r") as file:
+        config = yaml.safe_load(file)
+        # print(config)
+    return config

utils/currency_converter.py

@@ -0,0 +1,16 @@
+import requests
+
+class CurrencyConverter:
+    def __init__(self, api_key: str):
+        self.base_url = f"https://v6.exchangerate-api.com/v6/{api_key}/latest/"
+    
+    def convert(self, amount:float, from_currency:str, to_currency:str):
+        """Convert the amount from one currency to another"""
+        url = f"{self.base_url}/{from_currency}"
+        response = requests.get(url)
+        if response.status_code != 200:
+            raise Exception("API call failed:", response.json())
+        rates = response.json()["conversion_rates"]
+        if to_currency not in rates:
+            raise ValueError(f"{to_currency} not found in exchange rates.")
+        return amount * rates[to_currency]

utils/expense_calculator.py

@@ -0,0 +1,43 @@
+class Calculator:
+    @staticmethod
+    def multiply(a: int, b: int) -> int:
+        """
+        Multiply two integers.
+
+        Args:
+            a (int): The first integer.
+            b (int): The second integer.
+
+        Returns:
+            int: The product of a and b.
+        """
+        return a * b
+    
+    @staticmethod
+    def calculate_total(*x: float) -> float:
+        """
+        Calculate sum of the given list of numbers
+
+        Args:
+            x (list): List of floating numbers
+
+        Returns:
+            float: The sum of numbers in the list x
+        """
+        return sum(x)
+    
+    @staticmethod
+    def calculate_daily_budget(total: float, days: int) -> float:
+        """
+        Calculate daily budget
+
+        Args:
+            total (float): Total cost.
+            days (int): Total number of days
+
+        Returns:
+            float: Expense for a single day
+        """
+        return total / days if days > 0 else 0
+    
+    

utils/model_loader.py

@@ -0,0 +1,67 @@
+import os
+from dotenv import load_dotenv
+from utils.config_loader import load_config
+from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI, AzureChatOpenAI
+from azure.identity import AzureCliCredential, ManagedIdentityCredential
+
+# Load .env file
+load_dotenv()
+
+class ConfigLoader:
+    def __init__(self):
+        print("Loading config...")
+        self.config = load_config()
+
+    def __getitem__(self, key):
+        return self.config[key]
+
+
+class ModelLoader:
+    def __init__(self, model_provider: str = "azureopenai"):
+        
+        print(f"Initializing ModelLoader with provider: {model_provider}")
+        self.model_provider = model_provider.lower()
+        self.config = ConfigLoader()
+
+    def load_llm(self):
+        self.model_provider = "groq"
+        print(f"LLM loading from provider: {self.model_provider}")
+
+        if self.model_provider == "groq":
+            print("→ Using Groq")
+            groq_api_key = os.getenv("GROQ_API_KEY")
+            print(f"Groq API Key: {groq_api_key}")
+            if not groq_api_key:
+                raise ValueError("GROQ_API_KEY environment variable is not set.")
+            model_name = self.config["llm"]["groq"]["model_name"]
+            return ChatGroq(model=model_name, api_key=groq_api_key)
+
+        elif self.model_provider == "openai":
+            print("→ Using OpenAI")
+            openai_api_key = os.getenv("OPENAI_API_KEY")
+            model_name = self.config["llm"]["openai"]["model_name"]
+            return ChatOpenAI(model_name=model_name, api_key=openai_api_key)
+
+        elif self.model_provider == "azureopenai":
+            print("→ Using Azure OpenAI")
+            client_id = os.getenv("AZURE_MANAGED_IDENTITY_CLIENT_ID")
+            if client_id and len(client_id) > 1: 
+                credential = ManagedIdentityCredential(client_id=client_id)
+            else:
+                credential = AzureCliCredential()
+            
+            token = credential.get_token("https://cognitiveservices.azure.com/.default").token
+            if not token:
+                raise ValueError("Azure token could not be retrieved.")
+            return AzureChatOpenAI(
+                azure_endpoint=self.config["llm"]["azureopenai"]["endpoint"],
+                azure_deployment=self.config["llm"]["azureopenai"]["model_name"],
+                api_version=self.config["llm"]["azureopenai"]["api_version"],
+                api_key=token
+            )
+
+        else:
+            raise ValueError(f"Unsupported model provider: {self.model_provider}")
+
+    

utils/place_info_search.py

@@ -0,0 +1,78 @@
+import os
+import json
+from langchain_tavily import TavilySearch
+from langchain_google_community import GooglePlacesTool, GooglePlacesAPIWrapper 
+
+class GooglePlaceSearchTool:
+    def __init__(self, api_key: str):
+        self.places_wrapper = GooglePlacesAPIWrapper(gplaces_api_key=api_key)
+        self.places_tool = GooglePlacesTool(api_wrapper=self.places_wrapper)
+    
+    def google_search_attractions(self, place: str) -> dict:
+        """
+        Searches for attractions in the specified place using GooglePlaces API.
+        """
+        return self.places_tool.run(f"top attractive places in and around {place}")
+    
+    def google_search_restaurants(self, place: str) -> dict:
+        """
+        Searches for available restaurants in the specified place using GooglePlaces API.
+        """
+        return self.places_tool.run(f"what are the top 10 restaurants and eateries in and around {place}?")
+    
+    def google_search_activity(self, place: str) -> dict:
+        """
+        Searches for popular activities in the specified place using GooglePlaces API.
+        """
+        return self.places_tool.run(f"Activities in and around {place}")
+
+    def google_search_transportation(self, place: str) -> dict:
+        """
+        Searches for available modes of transportation in the specified place using GooglePlaces API.
+        """
+        return self.places_tool.run(f"What are the different modes of transportations available in {place}")
+
+class TavilyPlaceSearchTool:
+    def __init__(self):
+        pass
+
+    def tavily_search_attractions(self, place: str) -> dict:
+        """
+        Searches for attractions in the specified place using TavilySearch.
+        """
+        tavily_tool = TavilySearch(topic="general", include_answer="advanced")
+        result = tavily_tool.invoke({"query": f"top attractive places in and around {place}"})
+        if isinstance(result, dict) and result.get("answer"):
+            return result["answer"]
+        return result
+    
+    def tavily_search_restaurants(self, place: str) -> dict:
+        """
+        Searches for available restaurants in the specified place using TavilySearch.
+        """
+        tavily_tool = TavilySearch(topic="general", include_answer="advanced")
+        result = tavily_tool.invoke({"query": f"what are the top 10 restaurants and eateries in and around {place}."})
+        if isinstance(result, dict) and result.get("answer"):
+            return result["answer"]
+        return result
+    
+    def tavily_search_activity(self, place: str) -> dict:
+        """
+        Searches for popular activities in the specified place using TavilySearch.
+        """
+        tavily_tool = TavilySearch(topic="general", include_answer="advanced")
+        result = tavily_tool.invoke({"query": f"activities in and around {place}"})
+        if isinstance(result, dict) and result.get("answer"):
+            return result["answer"]
+        return result
+
+    def tavily_search_transportation(self, place: str) -> dict:
+        """
+        Searches for available modes of transportation in the specified place using TavilySearch.
+        """
+        tavily_tool = TavilySearch(topic="general", include_answer="advanced")
+        result = tavily_tool.invoke({"query": f"What are the different modes of transportations available in {place}"})
+        if isinstance(result, dict) and result.get("answer"):
+            return result["answer"]
+        return result
+    

utils/save_to_document.py

@@ -0,0 +1,40 @@
+import os
+import datetime
+
+def save_document(response_text: str, directory: str = "./output"):
+    """Export travel plan to Markdown file with proper formatting"""
+    os.makedirs(directory, exist_ok=True)
+    
+    
+    # Create markdown content with metadata header
+    markdown_content = f"""# 🌍 AI Travel Plan
+
+    # **Generated:** {datetime.datetime.now().strftime('%Y-%m-%d at %H:%M')}  
+    # **Created by:** kube9t's Travel Agent
+
+    ---
+
+    {response_text}
+
+    ---
+
+    *This travel plan was generated by AI. Please verify all information, especially prices, operating hours, and travel requirements before your trip.*
+    """
+            
+    try:
+        # Write to markdown file with UTF-8 encoding
+        # Generate timestamp-based filename
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        filename = f"{directory}/AI_Trip_Planner_{timestamp}.md"
+
+        print(filename)
+
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(markdown_content)
+        
+        print(f"Markdown file saved as: {filename}")
+        return filename
+        
+    except Exception as e:
+        print(f"Error saving markdown file: {e}")
+        return None

utils/weather_info.py

@@ -0,0 +1,34 @@
+import requests
+
+class WeatherForecastTool:
+    def __init__(self, api_key:str):
+        self.api_key = api_key
+        self.base_url = "https://api.openweathermap.org/data/2.5"
+
+    def get_current_weather(self, place:str):
+        """Get current weather of a place"""
+        try:
+            url = f"{self.base_url}/weather"
+            params = {
+                "q": place,
+                "appid": self.api_key,
+            }
+            response = requests.get(url, params=params)
+            return response.json() if response.status_code == 200 else {}
+        except Exception as e:
+            raise e
+    
+    def get_forecast_weather(self, place:str):
+        """Get weather forecast of a place"""
+        try:
+            url = f"{self.base_url}/forecast"
+            params = {
+                "q": place,
+                "appid": self.api_key,
+                "cnt": 10,
+                "units": "metric"
+            }
+            response = requests.get(url, params=params)
+            return response.json() if response.status_code == 200 else {}
+        except Exception as e:
+            raise e