app.py

import gradio as gr
from huggingface_hub import InferenceClient

theme = gr.themes.Monochrome(
    primary_hue=gr.themes.Color(c100="#f5f5f3", c200="#fbfaf8", c300="#f9f9f9", c400="#eee9ee", c50="rgba(255, 255, 255, 1)", c500="rgba(0, 0, 0, 1)", c600="rgba(26.934374999999992, 26.934374999999992, 26.934374999999992, 1)", c700="rgba(10.943750000000012, 10.943750000000012, 10.943750000000012, 1)", c800="rgba(17.053125000000005, 17.053125000000005, 17.053125000000005, 1)", c900="#fffefe", c950="#fffefe"),
    secondary_hue=gr.themes.Color(c100="#f29c74", c200="#f4b7a8", c300="#fffefe", c400="#fffefe", c50="#e46e45", c500="#fffefe", c600="#fffefe", c700="#fffefe", c800="#fffefe", c900="#fffefe", c950="#fffefe"),
    neutral_hue=gr.themes.Color(c100="#6b8ea8", c200="#a4c5e8", c300="rgba(0, 0, 0, 1)", c400="rgba(0, 0, 0, 1)", c50="#284566", c500="rgba(0, 0, 0, 1)", c600="rgba(0, 0, 0, 1)", c700="rgba(0, 0, 0, 1)", c800="rgba(0, 0, 0, 1)", c900="rgba(0, 0, 0, 1)", c950="rgba(0, 0, 0, 1)"),
    font=[gr.themes.GoogleFont('open sans'), 'ui-sans-serif', 'system-ui', 'sans-serif'],
).set(
    body_background_fill='*primary_50',
    body_background_fill_dark='*primary_700',
    body_text_color='*primary_500',
    body_text_color_dark='*primary_400',
    body_text_color_subdued='*neutral_50',
    body_text_color_subdued_dark='*primary_300',
    background_fill_primary='*primary_400',
    background_fill_primary_dark='*neutral_100',
    background_fill_secondary='*primary_400',
    background_fill_secondary_dark='*neutral_50',
    border_color_accent_dark='*secondary_50',
    border_color_accent_subdued_dark='*primary_50',
    border_color_primary='*neutral_50',
    border_color_primary_dark='*neutral_100',
    color_accent='*primary_50',
    color_accent_soft_dark='*neutral_100',
    block_background_fill_dark='*neutral_50',
    checkbox_background_color='*primary_400',
    checkbox_background_color_selected='*primary_700',
    checkbox_background_color_selected_dark='*neutral_50',
    checkbox_label_border_color_dark='*neutral_50',
    input_background_fill='*primary_50',
    input_background_fill_dark='*neutral_100',
    input_border_color='*neutral_50',
    input_border_color_dark='*neutral_50',
    input_border_width='2px',
    table_odd_background_fill='*neutral_100',
    button_primary_background_fill='*neutral_50',
    button_primary_background_fill_dark='*neutral_100',
    button_primary_background_fill_hover='*neutral_100'
)

#STEP 1 FROM SEMATIC SEARCH
from sentence_transformers import SentenceTransformer
import torch

#STEP 2 FROM SEMATIC SEARCH
# Open the weather.txt file in read mode with UTF-8 encoding
with open("weather.txt", "r", encoding="utf-8") as file:
  # Read the entire contents of the file and store it in a variable
  weather_text = file.read()
with open("luggage.txt", "r", encoding="utf-8") as file:
  # Read the entire contents of the file and store it in a variable
  luggage_text = file.read()
with open("attractions.txt", "r", encoding="utf-8") as file:
  # Read the entire contents of the file and store it in a variable
  attraction_text = file.read()
with open("food.txt", "r", encoding="utf-8") as file:
  # Read the entire contents of the file and store it in a variable
  food_text = file.read()

#STEP 3 FROM SEMATIC SEARCH
def preprocess_text(text):
  # Strip extra whitespace from the beginning and the end of the text
  cleaned_text = text.strip()
  # Split the cleaned_text by every newline character (\n)
  chunks = cleaned_text.split("***")
  # Create an empty list to store cleaned chunks
  cleaned_chunks = []
  # Write your for-in loop below to clean each chunk and add it to the cleaned_chunks list
  for chunk in chunks:
    chunk.strip()
    if chunk != "":
      cleaned_chunks.append(chunk)
  return cleaned_chunks

# Call the preprocess_text function and store the result in a cleaned_chunks variable
cleaned_chunks_weather = preprocess_text(weather_text) # Complete this line
cleaned_chunks_luggage = preprocess_text(luggage_text)
cleaned_chunks_attraction = preprocess_text(attraction_text)
cleaned_chunks_food = preprocess_text(food_text)

#STEP 4 FROM SEMATIC SEARCH
# Load the pre-trained embedding model that converts text to vectors
model = SentenceTransformer('all-MiniLM-L6-v2')

def create_embeddings(text_chunks):
  # Convert each text chunk into a vector embedding and store as a tensor
  chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True) # Replace ... with the text_chunks list
  return chunk_embeddings

# Call the create_embeddings function and store the result in a new chunk_embeddings variable
chunk_embeddings_weather = create_embeddings(cleaned_chunks_weather) # Complete this line
chunk_embeddings_luggage = create_embeddings(cleaned_chunks_luggage)
chunk_embeddings_attraction = create_embeddings(cleaned_chunks_attraction)
chunk_embeddings_food = create_embeddings(cleaned_chunks_food)

#STEP 5 FROM SEMATIC SEARCH
# Define a function to find the most relevant text chunks for a given query, chunk_embeddings, and text_chunks
def get_top_chunks(query, chunk_embeddings, text_chunks):
  # Convert the query text into a vector embedding
  query_embedding = model.encode(query, convert_to_tensor = True) # Complete this line
  # Normalize the query embedding to unit length for accurate similarity comparison
  query_embedding_normalized = query_embedding / query_embedding.norm()
  # Normalize all chunk embeddings to unit length for consistent comparison
  chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True)
  # Calculate cosine similarity between query and all chunks using matrix multiplication
  similarities = torch.matmul(chunk_embeddings_normalized, query_embedding_normalized) # Complete this line
  # Print the similarities
  #print(similarities)
  # Find the indices of the 3 chunks with highest similarity scores
  top_indices = torch.topk(similarities, k=3).indices
  # Print the top indices
  #print(top_indices)
  # Create an empty list to store the most relevant chunks
  top_chunks = []
  # Loop through the top indices and retrieve the corresponding text chunks
  for top_index in top_indices:
    top_chunks.append(text_chunks[top_index])
  # Return the list of most relevant chunks
  return top_chunks

#STEP 6 FROM SEMANTIC SEARCH

client = InferenceClient("Qwen/Qwen2.5-72B-Instruct")

def respond(message, history, language, chatbot_mode, destinations, trip_length, trip_unit, trip_season, luggage_types, luggage_size, food_prefs, activity):
    destinations = destinations or []
    trip_length = trip_length or "Not specified"
    trip_unit = trip_unit or ""
    trip_season = trip_season or "Not specified"
    luggage_types = luggage_types or []
    luggage_size = luggage_size or "Not specified"
    food_prefs = food_prefs or []
    activity = activity or []
    language = language or "English"

    #conduct a semantic search for each of our files
    top_weather = get_top_chunks(message, chunk_embeddings_weather, cleaned_chunks_weather)
    top_luggage = get_top_chunks(message, chunk_embeddings_luggage, cleaned_chunks_luggage)
    top_attraction = get_top_chunks(message, chunk_embeddings_attraction, cleaned_chunks_attraction)
    top_food = get_top_chunks(message, chunk_embeddings_food, cleaned_chunks_food)
    
    str_top_weather = "\n".join(top_weather)
    str_top_luggage = "\n".join(top_luggage)
    str_top_attraction = "\n".join(top_attraction)
    str_top_food = "\n".join(top_food)

    #collect inputed data from the sidebar elements
    ctx = (
        f"Language: {language}"
        f"Destination: {', '.join(destinations) if destinations else 'Not specified'}\n"
        f"Trip Length: {trip_length} {trip_unit}\n"
        f"Trip Season: {trip_season}\n"
        f"Luggage: {', '.join(luggage_types) if luggage_types else 'Not specified'}, "
        f"Size: {luggage_size}L\n"
        f"Food Preferences: {', '.join(food_prefs) if food_prefs else 'Not specified'}\n"
        f"Activity Preferences: {', '.join(activity) if activity else 'Not specified'}\n"
    )

    if chatbot_mode == "Packing":
        messages = [{
            "role": "system",
            "content": (
                f"You are a friendly and Gen Z travel chatbot helping with packing advice.\n\n"
                f"{ctx}\n"
                f"Relevant context:\n{str_top_weather}\n{str_top_luggage}"
                f"Please respond in {language}"
            )
        }]
    elif chatbot_mode == "Food/Attractions":
        messages = [{
            "role": "system",
            "content": (
                f"You are a friendly and Gen Z travel chatbot recommending food and attractions.\n\n"
                f"{ctx}\n"
                f"Relevant context:\n{str_top_food}\n{str_top_attraction}"
                f"Please respond in {language}"
            )
        }]
    else:
        messages = [{
            "role": "system",
            "content": (
                f"You are a friendly and Gen Z travel chatbot helping travelers plan trips to San Francisco and/or Los Angeles.\n\n"
                f"{ctx}\n"
                f"Use relevant context:\n{str_top_weather}\n{str_top_luggage}\n{str_top_food}\n{str_top_attraction}"
                f"Please respond in {language}"
            )
        }]

    if history:
        for user_msg, bot_reply in history:
            messages.append({"role": "user", "content": user_msg})
            messages.append({"role": "assistant", "content": bot_reply})

    messages.append({"role": "user", "content": message})

    response = client.chat_completion(
        messages,
        max_tokens =  2000,
        temperature = 1
    )

    if isinstance(response, dict):
        reply = response['choices'][0]['message']['content'].strip()
    else:
        reply = response.strip()
    
    history.append((message, reply))
    return history, ""
    
def reset_inputs():
    return (
        None,  # language
        None,  # chatbot_mode
        [],    # destinations
        None,  # trip_length
        None,  # trip_unit
        None,  # trip_season
        [],    # luggage_types
        20,    # luggage_size (default)
        [],    # food_prefs
        []     # activity
    )

def update_visibility(chatbot_mode):
        if chatbot_mode == "Packing":
            return gr.update(visible=True), gr.update(visible=False)
        elif chatbot_mode == "Food/Attractions":
            return gr.update(visible=False), gr.update(visible=True)
        else:
            return gr.update(visible=True), gr.update(visible=True)

with gr.Blocks(theme=theme) as demo:
    with gr.Row():
        # ─── left column: your controls ───
        with gr.Column(scale=1):
            gr.Markdown("### Chatbot Settings")
            language = gr.Radio(
                choices=["English","Español", "Italiano", "Français", "日本語", "中文"],
                label="What language would you like to use?"
            )
            chatbot_mode = gr.Radio(
                choices=["Packing", "Food/Attractions"],
                label="What do you need help with?"
            )
            gr.Markdown("### Destination")
            destinations = gr.CheckboxGroup(
                choices=["San Francisco","Los Angeles"],
                label="Where are you going?"
            )
            gr.Markdown("### Trip Length")
            trip_length = gr.Number(label="How long is your trip?", precision=0)
            trip_unit = gr.Radio(
                choices=["day", "week", "month"],
                label="Trip length unit:"
            )
            trip_season = gr.Radio(
                choices=["Warm/Dry (May to October)", "Cool/Wet (November to April)"],
                label="Season:"
            )
            
            with gr.Group(visible=True) as packing_group:
                #gr.Markdown("### Luggage")
                luggage_types = gr.CheckboxGroup(
                    choices=["Carry-on", "Checked"],
                    label="What is your luggage type?"
                )
                luggage_size = gr.Slider(
                    minimum=10, maximum=100, step=10, value=20,
                    label="What is the size of your luggage (liters)?"
                )
            
            with gr.Group(visible=True) as food_group:
                    #gr.Markdown("### Food")
                    food_prefs = gr.Dropdown(
                        choices=["Italian", "Thai", "Mexican", "Japanese", "Vegan", "Seafood"],
                        multiselect=True,
                        label="What are your food preferences?"
                    )
            
                    #gr.Markdown("### Activities")
                    activity = gr.Dropdown(
                        choices=["Outdoor & Nature", "Indoor", "Museums", "Shopping", "Relaxation"],
                        multiselect=True,
                        label="What are your activity preferences?"
                    )

            chatbot_mode.change(
                fn=update_visibility,
                inputs=[chatbot_mode],
                outputs=[packing_group, food_group]
            )

            reset_btn = gr.Button("Reset All", variant="secondary")
            reset_btn.click(
                fn=reset_inputs,
                inputs=[],
                outputs=[
                    language,
                    chatbot_mode,
                    destinations,
                    trip_length,
                    trip_unit,
                    trip_season,
                    luggage_types,
                    luggage_size,
                    food_prefs,
                    activity
                ]
            )

        with gr.Column(scale=3):
            gr.Image(value="Go Buddy2.png", interactive=False, show_label=False)

            # 1) the chat history panel
            chat_box = gr.Chatbot(height=900)

            # 2) where the user types
            msg = gr.Textbox(
                placeholder="Ask me anything…",
                lines=1,
                label = "How can we help you?"
            )

            # 3) send button
            send_btn = gr.Button("Send")

            # 4) hook up the click event
            send_btn.click(
                fn=respond,
                inputs=[
                    msg,            
                    chat_box,       
                    language,
                    chatbot_mode,
                    destinations,
                    trip_length,
                    trip_unit,
                    trip_season, 
                    luggage_types,
                    luggage_size,
                    food_prefs, 
                    activity
                ],
                outputs=[chat_box, msg] 
            )
            msg.submit(
                fn=respond,
                inputs=[
                    msg,
                    chat_box,
                    language,
                    chatbot_mode,
                    destinations,
                    trip_length,
                    trip_unit,
                    trip_season, 
                    luggage_types,
                    luggage_size,
                    food_prefs, 
                    activity
                ],
                outputs=[chat_box, msg]
            )


demo.launch(debug=True)