Auto-deploy from GitHub: 1fbc6e7e1a7e8157edee173a9390286563fe3106

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

DEPLOYMENT.md

@@ -0,0 +1,220 @@
+# Deploying NaviBlu Chatbot to Hugging Face Spaces
+
+This guide explains how to deploy the NaviBlu chatbot to Hugging Face Spaces.
+
+> ⚠️ **Note**: As of April 2025, Hugging Face deprecated the built-in Streamlit SDK. Streamlit apps now require Docker. This folder is already configured for Docker deployment.
+
+## Prerequisites
+
+1. **Hugging Face Account**: Sign up at https://huggingface.co/
+2. **API Keys**: You'll need these as Secrets in your Space:
+   - `GROQ_API_KEY`
+   - `AMADEUS_API_KEY`
+   - `AMADEUS_API_SECRET`
+
+## Files in This Folder
+
+All files needed for Hugging Face Spaces deployment:
+
+```
+chatbot/
+├── app.py               # Streamlit entry point
+├── core.py              # Core chatbot logic
+├── __init__.py          # Module initialization
+├── Dockerfile           # Docker configuration (required)
+├── README.md            # HF Space metadata (YAML frontmatter)
+├── requirements.txt     # Python dependencies
+├── packages.txt         # System dependencies (apt-get)
+├── DEPLOYMENT.md        # This guide
+└── .streamlit/
+    └── config.toml      # Streamlit configuration
+```
+
+## Deployment Steps
+
+### Step 1: Create a New Hugging Face Space
+
+1. Go to https://huggingface.co/new-space
+2. Configure:
+   - **Space name**: `naviblu-travel-assistant` (or your choice)
+   - **License**: MIT (or your preference)
+   - **SDK**: Select **Docker**
+   - **Hardware**: **CPU basic** (free tier is sufficient)
+3. Click **Create Space**
+
+### Step 2: Deploy the Chatbot Folder
+
+**Option A: Upload via Web Interface (Easiest)**
+
+1. In your new Space, click **Files** tab
+2. Click **Add file** → **Upload files**
+3. Upload ALL files from this `chatbot/` folder:
+   - `app.py`
+   - `core.py`
+   - `__init__.py`
+   - `Dockerfile`
+   - `README.md`
+   - `requirements.txt`
+   - `packages.txt`
+   - `.streamlit/config.toml` (create the folder structure)
+4. Commit the files
+
+**Option B: Git Push**
+
+1. Clone your new Space:
+   ```bash
+   git clone https://huggingface.co/spaces/YOUR-USERNAME/naviblu-travel-assistant
+   cd naviblu-travel-assistant
+   ```
+
+2. Copy files from the chatbot folder:
+   ```bash
+   cp -r /path/to/NaviBlu_Travel_Assistant/chatbot/* .
+   ```
+
+3. Push to Hugging Face:
+   ```bash
+   git add .
+   git commit -m "Deploy NaviBlu chatbot"
+   git push
+   ```
+
+### Step 3: Add API Keys as Secrets
+
+1. In your Space, go to **Settings** → **Repository secrets**
+2. Add the following secrets:
+   - **Name**: `GROQ_API_KEY`, **Value**: Your Groq API key
+   - **Name**: `AMADEUS_API_KEY`, **Value**: Your Amadeus API key
+   - **Name**: `AMADEUS_API_SECRET`, **Value**: Your Amadeus API secret
+
+### Step 4: Wait for Build
+
+The Space will build the Docker image and start (typically 3-7 minutes for first build). Monitor progress in the **App** tab or **Logs**.
+
+### Step 5: Test Your Space
+
+Your chatbot will be live at:
+```
+https://huggingface.co/spaces/YOUR-USERNAME/naviblu-travel-assistant
+```
+
+## Embedding in Website
+
+To embed in your website (`index.html`), update the iframe URL:
+
+```html
+<iframe src="https://YOUR-USERNAME-naviblu-travel-assistant.hf.space" 
+        class="streamlit-iframe" 
+        title="NaviBlu Travel Assistant">
+</iframe>
+```
+
+**Note**: The embed URL format for Docker Spaces is `https://USERNAME-SPACENAME.hf.space`
+
+## Understanding the Docker Setup
+
+### Dockerfile Explained
+
+```dockerfile
+FROM python:3.11-slim          # Base Python image
+WORKDIR /app                   # Set working directory
+COPY requirements.txt .        # Copy dependencies
+RUN pip install ...            # Install Python packages
+COPY . .                       # Copy all app files
+RUN useradd -m -u 1000 user   # Create non-root user (HF requirement)
+USER user                      # Switch to non-root user
+EXPOSE 8501                    # Expose Streamlit port
+CMD ["streamlit", "run", ...]  # Start command
+```
+
+### README.md YAML Frontmatter
+
+```yaml
+---
+title: NaviBlu Travel Assistant
+sdk: docker              # Required for Streamlit now
+app_port: 8501           # Streamlit's default port
+---
+```
+
+## Troubleshooting
+
+### Build Fails
+
+- Check **Logs** in the App tab for error messages
+- Verify Dockerfile syntax is correct
+- Ensure all files are uploaded (especially `requirements.txt`)
+
+### App Stuck on "Starting"
+
+- Make sure `app_port: 8501` is in README.md frontmatter
+- Verify Streamlit is configured to run on `0.0.0.0:8501`
+- Check that Dockerfile exposes port 8501
+
+### Import Errors
+
+- Ensure `core.py` and `__init__.py` are uploaded
+- Check that `app.py` imports use `from core import Chatbot` (not relative)
+
+### API Errors
+
+- Verify secrets are named exactly as expected (case-sensitive)
+- Test API keys independently to ensure they're valid
+
+### Permission Errors
+
+- The Dockerfile creates a non-root user - this is required by HF
+- Make sure you're not trying to write to system directories
+
+## Updating the Space
+
+### Option A: Automatic via GitHub Actions (Recommended)
+
+If you set up the GitHub Actions workflow, simply push changes to the `chatbot/` folder on GitHub - it will automatically deploy to Hugging Face!
+
+**One-time setup:**
+1. Go to your GitHub repo → **Settings** → **Secrets and variables** → **Actions**
+2. Add these secrets:
+   - `HF_TOKEN`: Your Hugging Face access token (from https://huggingface.co/settings/tokens)
+   - `HF_SPACE_NAME`: Your Space path (e.g., `your-username/naviblu-travel-assistant`)
+
+Then every push to `chatbot/` will auto-deploy!
+
+### Option B: Manual Push
+
+```bash
+# After making changes locally
+cd your-space-clone
+cp -r /path/to/chatbot/* .
+git add .
+git commit -m "Update chatbot"
+git push
+```
+
+### Option C: Web Upload
+
+Upload updated files through the Hugging Face web interface.
+
+## Cost
+
+- **CPU basic**: Free (sufficient for this chatbot)
+- **CPU upgrade**: ~$0.50/hour
+- **GPU**: Starting at ~$0.60/hour (not needed)
+
+## Why Hugging Face Spaces?
+
+✅ **Free tier** with good resources  
+✅ **Automatic HTTPS** and domain  
+✅ **Easy secrets management** for API keys  
+✅ **Git-based deployment**  
+✅ **Docker support** for full control  
+✅ **Good uptime** and reliability  
+✅ **Embed-friendly** for websites  
+
+## Next Steps
+
+1. ✅ Deploy chatbot to Hugging Face Spaces
+2. ✅ Test the Space URL directly
+3. ✅ Update `index.html` with new embed URL
+4. ✅ Deploy website to GitHub Pages
+5. ✅ Test the fully integrated experience

Dockerfile

@@ -1,20 +1,37 @@
-FROM python:3.13.5-slim
+# Hugging Face Spaces Dockerfile for Streamlit
+FROM python:3.11-slim
 
+# Set working directory
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Install system dependencies
+COPY packages.txt .
+RUN apt-get update && \
+    xargs -a packages.txt apt-get install -y && \
+    rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+# Copy application files
+COPY . .
 
+# Create a non-root user for security (required by HF Spaces)
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    STREAMLIT_SERVER_PORT=8501 \
+    STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+# Expose the Streamlit port
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +1,42 @@
 ---
 title: NaviBlu Travel Assistant
-emoji: 🚀
-colorFrom: red
-colorTo: red
+emoji: ✈️
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 app_port: 8501
-tags:
-- streamlit
 pinned: false
-short_description: AI chatbot to provide flight, hotel, and general travel info
+license: mit
 ---
 
-# Welcome to Streamlit!
+# NaviBlu Travel Assistant
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+AI-powered travel chatbot that helps you find flights, hotels, and discover destinations.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+Built with Streamlit and powered by Meta's Llama 3.3 70B model via Groq.
+
+## Features
+
+- ✈️ **Flight Search** - Find flights from 400+ airlines
+- 🏨 **Hotel Search** - Browse 150,000+ hotels worldwide
+- 📍 **Location Info** - Discover attractions and activities
+- 💬 **Natural Conversation** - Just chat naturally, no forms needed
+
+## Usage
+
+Simply type your travel questions in the chat, for example:
+- "Find me flights from New York to London next weekend"
+- "What hotels are available in Paris this Friday?"
+- "What are popular things to do in Tokyo?"
+
+## API Keys Required
+
+This Space requires the following secrets to be configured:
+- `GROQ_API_KEY` - For LLM inference
+- `AMADEUS_API_KEY` - For hotel data
+- `AMADEUS_API_SECRET` - For hotel data
+
+## Credits
+
+**ITCS 6112 - Group 5**  
+Cameron Detig • Juan Rojas • Evelyn Hosana • Varsha Chintalapati

__init__.py

@@ -0,0 +1,9 @@
+"""
+NaviBlu Travel Assistant - Chatbot Module
+
+This module contains the core chatbot logic and Streamlit UI.
+"""
+
+from .core import Chatbot
+
+__all__ = ['Chatbot']

app.py

@@ -0,0 +1,47 @@
+# Hugging Face Space Entry Point for NaviBlu Travel Assistant
+
+import streamlit as st
+import os
+from core import Chatbot
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+# Initialize chat history in streamlit session state
+if "messages" not in st.session_state or st.session_state.messages is None:
+    st.session_state.messages = []
+
+
+# Initialize chatbot object in streamlit session state
+if "chatbot" not in st.session_state or st.session_state.chatbot is None:
+    st.session_state.chatbot = Chatbot()
+
+
+# Streamlit App ----------------------------------------------------------------------
+
+st.title("NaviBlu Travel Assistant")
+
+# Display chat messages from history on app rerun
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Accept user input
+if prompt := st.chat_input("Type Here"):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+
+    with st.chat_message("user"):
+        # Display user query in UI
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+
+        # Call shared chatbot logic
+        response = st.session_state.chatbot.process_input(prompt) # type: ignore
+
+        # Display response in UI
+        st.markdown(response)
+
+    # Add response to chat history
+    st.session_state.messages.append({"role": "assistant", "content": response})

core.py

@@ -0,0 +1,375 @@
+# Core backend chatbot logic with agent-based architecture
+
+import os
+import json
+from datetime import date
+from amadeus import Client, ResponseError # Hotels API
+from fast_flights import FlightData, Passengers, Result, get_flights # Flights API
+from groq import Groq
+from dotenv import load_dotenv
+load_dotenv()
+
+
+# Chatbot --------------------------------------------------------------------------------
+
+class Chatbot():
+    def __init__(self):
+        self.input_prompt = ""
+        self.todays_date = date.today().isoformat()
+
+        self.LLM_model = "llama-3.3-70b-versatile"
+
+        self.amadeus = Client(
+            client_id = os.getenv("AMADEUS_API_KEY"),
+            client_secret = os.getenv("AMADEUS_API_SECRET")
+        )
+
+        # chat_history to store all of the messages in the conversation.
+        # Set the system prompt to establish the behavior of the chatbot.
+        self.chat_history = [
+                                {"role": "system", 
+                                "content": "You are a travel assistant named NaviBlu who helps provide information to users for planning trips and vacations."}
+                            ]
+        # seperate history to store just the user's messages
+        self.user_message_history = []
+
+        self.flight_info = ""
+        self.hotel_info = ""
+        self.location_info = ""
+        self.general_info = ""
+
+        # establish Groq client for API calls
+        self.client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+
+
+
+    def process_input(self, input_prompt:str):
+        '''Determine if the user prompt is asking for information on flights, hotels, location, or general info.'''
+
+        print("Running process_input function")
+
+        self.input_prompt = input_prompt
+        print(f"Input prompt: {self.input_prompt}")
+
+        # Reset info
+        self.flight_info = ""
+        self.hotel_info = ""
+        self.location_info = ""
+        self.general_info = ""
+
+        # Add to chat history
+        self.chat_history.append({"role": "user", "content": str(self.input_prompt)})
+        self.user_message_history.append({"role": "user", "content": str(self.input_prompt)})
+        
+        # make seperate chat history just for this process
+        process_input_history = [{
+                                    "role": "system", 
+                                    "content": """You are an AI assistant tasked with determining if the user's most recent prompt is looking for the categories of 'flight', 'hotel', 'location', or 'general' information.
+                                                If a category has already been used in an earlier assistant message and the most recent user message does not require it to be run again, do not run it again!! Just return the category they are currently looking for.
+                                                Return only the names of the categories the prompt is asking about, 'flight', 'hotel', 'location', or 'general'. Only include 'location' if the user is asking for information about attractions and activities at a location.
+                                                
+                                                Here are some examples to follow:
+                                                user: can you find flights to New York?
+                                                assistant: flight
+
+                                                user: can you find hotels in vancouver this weekend?
+                                                assistant: hotel
+
+                                                user: what are hotels near popular tourist locations in Orlando?
+                                                assistant: hotel, location
+
+                                                user: help me plan an entire trip from Charlotte to London this weekend.
+                                                assistant: flight, hotel, location
+
+                                                user: what are some popular activities to do in Wellington, New Zealand?
+                                                assistant: location
+
+                                                user: How far is Tokyo from New York?
+                                                assistant: general
+                                                """
+                                }]
+        
+        # Add all of the user's messages to process_input_history
+        for message in self.chat_history:
+            process_input_history.append(message)
+
+
+        completion = self.client.chat.completions.create(
+            model = self.LLM_model,
+            messages = process_input_history, # type: ignore
+            temperature = 0.1
+        )
+
+        categories = str(completion.choices[0].message.content)
+        print(f"---User Query Categories: {categories}---")
+        self.user_message_history.append({"role": "assistant", "content": str(categories)}) # Add what agents were called for each query
+
+        if ("flight" in categories):
+            self.flight_info = self.flight_agent()
+
+        if ("hotel" in categories):
+            self.hotel_info = self.hotel_agent()
+
+        if ("location" in categories):
+            self.location_info = self.location_agent()
+
+        if ("general" in categories or len(categories) == 0):
+            self.general_info = self.general_info_agent()
+        
+
+        # Combine the responses of all the agents
+        assistant_response = f"{self.flight_info}\n + {self.hotel_info}\n + {self.location_info}\n + {self.general_info}"
+
+        # Add AI response to chat history
+        self.chat_history.append({"role": "assistant", "content": assistant_response})
+
+        print("Outputing Message.\n")
+        return assistant_response
+    
+
+
+
+
+    def flight_agent(self):
+        """Uses an LLM to parse flight parameters the user is searching for. Then uses an API to search for available flights."""
+        print("Running flight agent.")
+
+        flight_info_prompt = f"""Use this user message history to extract the flight information the user is currently looking for: 
+                user message history: {self.user_message_history}
+                format your response as a json exactly structured like below and nothing else. If you can't find information for a section, make an educated guess based on the message history. 
+                If needed, today's date is {self.todays_date}.
+
+                {{
+                "tripType": either "round-trip" or "one-way",
+                "originCity": three letter origin city iataCode,
+                "destinationCity": three letter destination city iataCode,
+                "originAirport": three letter origin airport code based on the city,
+                "destinationAirport": three letter destination airport code based on the city,
+                "departureDate": "YYY-MM-DD",
+                "arrivalDate": "YYY-MM-DD" if tripType is one-way, enter "None" for this field,
+                "numAdults": X If no number is specified, assume 2,
+                "numChildren": X If no number is specified, assume 0,
+                "seat": either "economy", "premium-economy", "business", or "first". If no specification is made, enter "economy"
+                }}
+                """
+        
+        # Use LLM to parse flight search parameters from prompt
+        search_info = self.call_llm(prompt = flight_info_prompt)
+        # convert to JSON
+        search_info_json = json.loads(search_info) # type: ignore
+
+        output = ["Flight Search Parameters:"]
+        output.append("--------------------------------------------------------")
+        output.append(f"Trip Type: {search_info_json.get("tripType")},   Seat Type: {search_info_json.get("seat")}")
+        output.append(f"Origin City: {search_info_json.get("originCity")},   Destination City: {search_info_json.get("destinationCity")}")
+        output.append(f"Origin Airport: {search_info_json.get("originAirport")},   Destination Airport: {search_info_json.get("destinationAirport")}")
+        if search_info_json.get("tripType") == "one-way":
+            output.append(f"Departure: {search_info_json.get("departureDate")}")
+        else:
+            output.append(f"Departure: {search_info_json.get("departureDate")},   Arrival: {search_info_json.get("arrivalDate")}")
+        output.append(f"Adults: {search_info_json.get("numAdults")},   Children: {search_info_json.get("numChildren")}\n")
+
+
+
+        # get info for outbound flight 
+        outbound: Result = get_flights(
+            flight_data=[
+                FlightData(date=search_info_json.get("departureDate"), from_airport=search_info_json.get("originAirport"), to_airport=search_info_json.get("destinationAirport"))
+            ],
+            trip="one-way",
+            seat=search_info_json.get("seat"),
+            passengers=Passengers(adults=search_info_json.get("numAdults"), children=search_info_json.get("numChildren"), infants_in_seat=0, infants_on_lap=0),
+            fetch_mode="fallback",
+        )
+
+        output.append("Outbound Flights:-----------------------------------")
+        output.append(f"Current Prices: {outbound.current_price}\n")
+
+        for flight in outbound.flights:
+            if flight.is_best == True:
+                #print(f"Is best?: {flight.is_best}")
+                output.append(f"Airline Name: {flight.name}")
+                output.append(f"Departure: {flight.departure}")
+                output.append(f"Arrival: {flight.arrival}")
+                output.append(f"Duration: {flight.duration}")
+                output.append(f"Stops: {flight.stops}")
+                output.append(f"Price: {flight.price}")
+                output.append("\n")
+
+
+        # If round-trip, get info for inbound flight as well. (fast-flights API doesn't support normal round-trip)
+        if search_info_json.get("tripType") == "round-trip":
+            inbound: Result = get_flights(
+                flight_data=[
+                    FlightData(date=search_info_json.get("arrivalDate"), from_airport=search_info_json.get("destinationAirport"), to_airport=search_info_json.get("originAirport"))
+                ],
+                trip="one-way",
+                seat=search_info_json.get("seat"),
+                passengers=Passengers(adults=search_info_json.get("numAdults"), children=search_info_json.get("numChildren"), infants_in_seat=0, infants_on_lap=0),
+                fetch_mode="fallback",
+            )
+
+            output.append("Inbound Flights:-----------------------------------")
+            output.append(f"Current Prices: {inbound.current_price}\n")
+
+            for flight in inbound.flights:
+                if flight.is_best == True:
+                    #print(f"Is best?: {flight.is_best}")
+                    output.append(f"Airline Name: {flight.name}")
+                    output.append(f"Departure: {flight.departure}")
+                    output.append(f"Arrival: {flight.arrival}")
+                    output.append(f"Duration: {flight.duration}")
+                    output.append(f"Stops: {flight.stops}")
+                    output.append(f"Price: {flight.price}")
+                    output.append("\n")
+
+                
+        output_string = ""                  
+        for line in output:
+            output_string += str(line) + "  \n"
+
+        print("\n\nFlight Output String:\n")
+        print(output_string)
+
+        return str(output_string)
+
+
+
+    def hotel_agent(self):
+        print("Running hotel agent.\n")
+
+        prompt = f"""Use this user message history to extract the hotel information the user is currently looking for: 
+                user message history: {self.user_message_history}
+                format your response as a json exactly structured like below and nothing else. If you can't find information for a section, make an educated guess based on the message history. 
+                If needed, today's date is {self.todays_date}.
+
+                {{
+                "city": three letter city iataCode,
+                "checkInDate": "YYY-MM-DD",
+                "checkOutDate": "YYY-MM-DD",
+                "numGuests": X  If no number is specified, assume it is 2
+                }}
+                """
+        
+        search_info = self.call_llm(prompt = prompt)
+        print(search_info)
+        print()
+
+        # convert to JSON
+        search_info_json = json.loads(search_info) # type: ignore
+        
+
+        # Get list of hotels by city code
+        hotel_response = self.amadeus.reference_data.locations.hotels.by_city.get(cityCode=search_info_json.get("city"))
+
+        # Make list of hotel Ids
+        hotel_ids = []
+        for hotel in hotel_response.data:
+            hotel_ids.append(str(hotel.get("hotelId")))
+            #print(hotel)
+
+        try:
+            hotel_offers = self.amadeus.shopping.hotel_offers_search.get(
+                hotelIds = hotel_ids[0:30], # search through first number of hotel ids
+                checkInDate = search_info_json.get("checkInDate"),
+                checkOutDate = search_info_json.get("checkOutDate"),
+                adults = search_info_json.get("numGuests")
+            )
+            num_hotels = len(hotel_offers.data)
+        except:
+            return "Unable to find that match the search criteria."
+
+
+
+        
+        if num_hotels >= 5:
+            hotels_to_display = hotel_offers.data[0:5]
+        elif num_hotels < 5 and num_hotels > 0:
+            hotels_to_display = hotel_offers.data[0:num_hotels]
+        else:
+            return "Unable to find that match the search criteria."
+        
+
+        output = ["\nHotel Search Parameters:"]
+        output.append("--------------------------------------------------------")
+        output.append(f"Check In Date: {hotels_to_display[0].get("offers")[0].get("checkInDate")}") # type: ignore
+        output.append(f"Check Out Date: {hotels_to_display[0].get("offers")[0].get("checkOutDate")}") # type: ignore
+        output.append(f"City: {search_info_json.get("city")}")
+
+        guests_info = "Guests: "
+        for key in hotels_to_display[0].get("offers")[0].get("guests"): # type: ignore
+            guests_info += f"{key}: {hotels_to_display[0].get("offers")[0].get("guests").get(key)}  " # type: ignore
+        output.append(guests_info)
+
+
+        for hotel in hotels_to_display:
+            try:
+                output.append("")
+                output.append("")
+                for key in hotel:
+                    if key == "hotel":
+                        output.append(f"Hotel Name : {hotel.get(key).get("name")}") # type: ignore
+
+                    elif key == "available":
+                        output.append(f"Available : {hotel.get(key)}") # type: ignore
+
+                    elif key == "offers":
+                        for offer in hotel.get(key): # type: ignore
+                            output.append(f"Room Type: {offer.get("room").get("typeEstimated").get("category")}")
+                            output.append(f"Beds: {offer.get("room").get("typeEstimated").get("beds")} {offer.get("room").get("typeEstimated").get("bedType")}")
+                            output.append(f"Price: {offer.get("price").get("currency")} base: ${offer.get("price").get("base")} total: ${offer.get("price").get("total")}")
+                            output.append(f"Average Price per night ${offer.get("price").get("variations").get("average").get("base")}")
+                            output.append(f"Description: {offer.get("room").get("description").get("text")}")
+            except:
+                print("Invalid Hotel Info")
+
+        
+        output.append("")
+        output_string = ""                  
+        for line in output:
+            output_string += str(line) + "  \n"
+
+        print("\n\nHotel Output String:")
+        print(output_string)
+
+        return str(output_string)
+
+
+
+    def location_agent(self):
+        print("Running location agent.")
+        location_prompt = f"Use this user prompt to provide relevant information on the requested location including popular tourist attractions and activities: {self.input_prompt}"
+        response = self.call_llm(prompt = location_prompt)
+        print(response)
+        print()
+        return response
+
+
+
+    def general_info_agent(self):
+        print("Running general info agent.")
+        general_prompt = f"Use this user prompt to provide relevant general information: {self.input_prompt}"
+        return self.call_llm(prompt = general_prompt)
+
+
+
+
+
+    def call_llm(self, prompt):
+        """function for general purpose LLM calls."""
+        print("--Running call_llm.")
+
+        # make chat history to send to LLM
+        history = [{
+                    "role": "user",
+                    "content": prompt,
+                    }]
+
+        # Call LLM
+        completion = self.client.chat.completions.create(
+            model = self.LLM_model,
+            messages = history, # type: ignore
+        )
+
+        return completion.choices[0].message.content

packages.txt

@@ -0,0 +1,2 @@
+# System packages required for the app (installed via apt-get)
+curl

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+amadeus
+fast_flights
+groq
+python-dotenv
+streamlit

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/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).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))