app.py

import gradio as gr
import random
from huggingface_hub import InferenceClient

import pandas as pd

from sentence_transformers import SentenceTransformer
import torch

# LOAD FILES

def load_files(path):
    with open(path, "r", encoding = "utf-8") as f:
        return f.read()

        
charities_text = load_files("charities.txt")
financial_advice_text = load_files("financial_advice.txt")


# 

### 
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("\n")

    # 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:
        stripped_chunk = chunk.strip()
        if len(stripped_chunk) > 0:
            cleaned_chunks.append(stripped_chunk)

    
    # Print the length of cleaned_chunks
    num_of_chunks = len(cleaned_chunks)
   # print(num_of_chunks)

 
    return cleaned_chunks

cleaned_charities = preprocess_text(charities_text)
cleaned_finance = preprocess_text(financial_advice_text)

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

### STEP 4
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

    # Print the chunk embeddings
    print(chunk_embeddings)

    # Print the shape of chunk_embeddings
    print(chunk_embeddings.shape)

    # Return the chunk_embeddings
    return chunk_embeddings

charity_embeddings = create_embeddings(cleaned_charities)
finance_embeddings = create_embeddings(cleaned_finance)

###STEP 5
# 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

   

    # Find the indices of the 3 chunks with highest similarity scores
    top_indices = torch.topk(similarities, k=3).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 i in top_indices:
        relevant_info = text_chunks[i]
        top_chunks.append(relevant_info)

    # Return the list of most relevant chunks
    return top_chunks

#CSV files
columns = ["TransactionID", "UserID", "Date", "Description", "Amount", "Type", "Extra1", "Extra2"]
spendings = pd.read_csv("september_transactions_detailed.csv", names = columns)
spendings['Amount'] = pd.to_numeric(spendings['Amount'], errors='coerce').fillna(0)

def get_advice(user_id):
    user_data = spendings[spendings['UserID'] == user_id]
    
    if user_data.empty:
        return "No spending data found for this user."
    
    # Only consider expenses
    expenses = user_data[user_data['Type'].str.lower() == "expense"]
    total_spent = expenses['Amount'].sum()
    category_spent = expenses.groupby('Description')['Amount'].sum().to_dict()
    
    advice = []
    for cat, amt in category_spent.items():
        if amt > total_spent * 0.3:
            advice.append(f"You spend a lot on {cat}. Consider budgeting here.")
    
    advice_text = " | ".join(advice) if advice else "Your spending looks balanced across categories."
    
    summary_text = f"Total spent: ${total_spent:.2f}. Category breakdown: {category_spent}. Advice: {advice_text}"
    
    return summary_text
    
#AI API being used
client= InferenceClient("openai/gpt-oss-20b")
#defining role of AI and user

information=""

def respond(message, history, chatbot_topic_values, chatbot_mode_values, user_id=1):
    topic_chunks = []
    if chatbot_topic_values and "Helping Charities" in chatbot_topic_values:
        topic_chunks = get_top_chunks(message, charity_embeddings, cleaned_charities)
    elif chatbot_topic_values and "Financial Aid" in chatbot_topic_values:
        topic_chunks = get_top_chunks(message, finance_embeddings, cleaned_finance)

    csv_advice = get_advice(user_id)
    
    if chatbot_mode_values and "General Advice" in chatbot_mode_values:
        role_message = (
            "You are a helpful and insightful chatbot who acts like a financial "
            "advisor of a university student. Respond in under five bullet points, "
            f"under 500 characters, using this context: {topic_chunks}"
        )
    elif chatbot_mode_values and "Personal Advice" in chatbot_mode_values:
        role_message = (
            "You are a helpful and insightful chatbot who acts like a financial "
            "DO NOT ask the user for additional numbers or input"
            f"Use the following spending data from the CSV file to provide advice {csv_advice}"
        )
    else:
        role_message = f"You are a helpful chatbot. Use this context: {topic_chunks}"
    messages = [{"role": "assistant", "content": role_message}]
    if history:
        messages.extend(history)
    messages.append({"role": "user", "content": message})

    response = client.chat_completion(messages, temperature=0.2)
    return response['choices'][0]['message']['content'].strip()


### STEP 6
# Call the preprocess_text function and store the result in a cleaned_chunks variable
cleaned_chunks = preprocess_text(financial_advice_text) # Complete this line
top_results = get_top_chunks("What financial advice you give me?", finance_embeddings, cleaned_finance) 


#Defining chatbot giving user a UI to interact, see their conversation history, and see new messages using built in gr feature
#ChatInterface requires at least one parameter(a function)
chatbot = gr.ChatInterface(respond,type="messages", title="Finance Management Hub", theme="Taithrah/Minimal")

def save_chat_history(history, username):
            if not username:
                username = "anonymous"
            
            timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
            filename = f"chat_history_{username}_{timestamp}.txt"
            
            with open(filename, "w", encoding="utf-8") as f:
                f.write(f"Chat History for {username} - {timestamp}\n\n")
                for exchange in history:
                    if isinstance(exchange, tuple) and len(exchange) == 2:
                        user_msg, bot_msg = exchange
                        f.write(f"User: {user_msg}\n")
                        f.write(f"Bot: {bot_msg}\n\n")
                    elif isinstance(exchange, dict):
                        # Handle dictionary format if needed
                        role = exchange.get("role", "unknown")
                        content = exchange.get("content", "")
                        f.write(f"{role.capitalize()}: {content}\n\n")  

            return filename

with gr.Blocks(
    theme=gr.themes.Soft(
        primary_hue="blue",
        secondary_hue="fuchsia",
        neutral_hue="gray",
        text_size="lg",
    
    ).set(
        background_fill_primary='*neutral_200',
        background_fill_secondary='neutral_100',
        background_fill_secondary_dark='secondary_500',
        border_color_accent='*secondary_400',
        border_color_accent_dark='*secondary_800',
        color_accent='*secondary_600',
        color_accent_soft='*secondary_200',
        color_accent_soft_dark='*secondary_800',
        button_primary_background_fill='*secondary_400',
        button_primary_background_fill_dark='*secondary_600', 
        button_primary_text_color='white', 
        button_primary_border_color='*secondary_700',
        button_primary_border_color_dark='*secondary_900'
    )
) as demo:
        with gr.Row(scale=1):
            chatbot_topic=gr.CheckboxGroup(["Helping Charities", "Financial Aid"], label="What would you like advice about?")
        with gr.Row(scale=1):
            chatbot_mode=gr.CheckboxGroup(["General Advice", "Personal Advice"], label="How would you like the chatbot to respond?")

        gr.ChatInterface(
            fn=lambda msg, hist, topic_vals, mode_vals: respond(msg, hist, topic_vals, mode_vals),
            title="Finance Management Hub",
            description="Ask about your personal finance",
            type="messages",
            additional_inputs=[chatbot_topic, chatbot_mode]
    )
#launching chatbot
demo.launch()