entire app

app.py

@@ -4,14 +4,16 @@ import os
 import time
 from supabase import create_client
 import pandas as pd
+import numpy as np
 from dotenv import load_dotenv
+from typing import List, Dict
 
 # Load environment variables
 load_dotenv()
 
 # Initialize OpenAI client
 client = OpenAI(
-    api_key=os.environ.get("API_TOKEN"),
+    api_key=os.environ.get("OPENAI_API_KEY"),
 )
 
 # Initialize Supabase client
@@ -20,83 +22,322 @@ supabase = create_client(
     os.getenv("SUPABASE_KEY", "")
 )
 
-def predict(message, history, system_prompt, model, max_tokens, temperature, top_p):
-    messages = [{"role": "system", "content": system_prompt}]
-    messages.extend(history if history else [])
-    messages.append({"role": "user", "content": message})
-    
-    start_time = time.time()
-    response = client.chat.completions.create(
-        model=model,
-        messages=messages,
-        max_tokens=max_tokens,
-        temperature=temperature,
-        top_p=top_p,
-        stop=None,
-        stream=True
+def get_embedding(text: str) -> List[float]:
+    """Get OpenAI embedding for text."""
+    response = client.embeddings.create(
+        model="text-embedding-3-small",
+        input=text
     )
+    return response.data[0].embedding
 
-    full_message = ""
-    first_chunk_time = None
-    last_yield_time = None
+def cosine_similarity(a: List[float], b: List[float]) -> float:
+    """Calculate cosine similarity between two vectors."""
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
 
-    for chunk in response:
-        if chunk.choices and chunk.choices[0].delta.content:
-            if first_chunk_time is None:
-                first_chunk_time = time.time() - start_time
+def sign_up_school(username, password, name, address_line1, city, state, zip_code, 
+                   school_type, educational_level, enrollment, title_i_status, 
+                   free_reduced_lunch_percentage, contact_email, additional_info):
+    try:
+        # First, create auth user
+        auth_response = supabase.auth.sign_up({
+            "email": username,
+            "password": password
+        })
+        user_id = auth_response.user.id
 
-            full_message += chunk.choices[0].delta.content
-            current_time = time.time()
-            chunk_time = current_time - start_time
-            print(f"Message received {chunk_time:.2f} seconds after request: {chunk.choices[0].delta.content}")  
+        # Create school profile text for embedding
+        profile_text = f"""
+        School: {name}
+        Type: {school_type}
+        Level: {educational_level}
+        Title I: {title_i_status}
+        Free/Reduced Lunch: {free_reduced_lunch_percentage}%
+        Additional Info: {additional_info}
+        """
+        
+        # Get embedding for school profile
+        profile_embedding = get_embedding(profile_text)
 
-            if last_yield_time is None or (current_time - last_yield_time >= 0.25):
-                yield full_message
-                last_yield_time = current_time
+        # Then, insert school details
+        school_data = {
+            "user_id": user_id,
+            "name": name,
+            "address_line1": address_line1,
+            "city": city,
+            "state": state,
+            "zip_code": zip_code,
+            "school_type": school_type,
+            "educational_level": educational_level,
+            "enrollment": enrollment,
+            "title_i_status": title_i_status,
+            "free_reduced_lunch_percentage": free_reduced_lunch_percentage,
+            "contact_email": contact_email,
+            "additional_info": additional_info,
+            "embedding": profile_embedding
+        }
+        
+        response = supabase.table('schools').insert(school_data).execute()
+        return "School profile created successfully!"
+    except Exception as e:
+        return f"Error: {str(e)}"
 
-    if full_message:
-        total_time = time.time() - start_time
-        full_message += f" (First Chunk: {first_chunk_time:.2f}s, Total: {total_time:.2f}s)"
-        yield full_message
+def login(username, password):
+    try:
+        response = supabase.auth.sign_in_with_password({
+            "email": username,
+            "password": password
+        })
+        return "Login successful!", response.user.id
+    except Exception as e:
+        return f"Error: {str(e)}", None
 
-def fetch_table_data(table_name):
+def search_grants(query, school_id=None):
     try:
-        response = supabase.table(table_name).select("*").execute()
-        df = pd.DataFrame(response.data)
+        # Get query embedding
+        query_embedding = get_embedding(query)
+        
+        # Get school profile data if available
+        school_data = None
+        if school_id:
+            school_response = supabase.table('schools').select("*").eq('id', school_id).execute()
+            if school_response.data:
+                school_data = school_response.data[0]
+        
+        # Get all grants
+        grants_response = supabase.table('grants').select("*").execute()
+        grants = grants_response.data
+        
+        # Calculate relevance scores using embeddings
+        scored_grants = []
+        for grant in grants:
+            if grant.get('embedding'):
+                # Calculate similarity between query and grant
+                query_similarity = cosine_similarity(query_embedding, grant['embedding'])
+                
+                # If we have school data, also consider school-grant similarity
+                school_similarity = 0
+                if school_data and school_data.get('embedding'):
+                    school_similarity = cosine_similarity(school_data['embedding'], grant['embedding'])
+                
+                # Combined score (70% query relevance, 30% school profile match)
+                total_score = (0.7 * query_similarity) + (0.3 * school_similarity)
+                
+                scored_grants.append({
+                    'Title': grant['title'],
+                    'Provider': grant['provider'],
+                    'Due_date': grant['due_date'],
+                    'Description': grant['description'],
+                    'Funding_amount': grant['funding_amount'],
+                    'Score': total_score
+                })
+        
+        # Sort by score and convert to DataFrame
+        scored_grants.sort(key=lambda x: x['Score'], reverse=True)
+        df = pd.DataFrame(scored_grants)
         return df
     except Exception as e:
         return f"Error: {str(e)}"
 
-with gr.Blocks() as demo:
+def chat_with_ai(message, history, grant_id=None, school_id=None):
+    try:
+        # Get grant and school data
+        grant_data = supabase.table('grants').select("*").eq('id', grant_id).execute()
+        school_data = supabase.table('schools').select("*").eq('id', school_id).execute()
+        
+        # Add context to the system prompt
+        system_prompt = f"""You are an AI assistant helping with grant applications.
+        Grant Details: {grant_data.data[0] if grant_data.data else 'Not specified'}
+        School Details: {school_data.data[0] if school_data.data else 'Not specified'}
+        
+        Your role is to help schools complete grant applications effectively by:
+        1. Understanding the grant requirements and eligibility criteria
+        2. Crafting responses that align with the school's profile and needs
+        3. Ensuring all responses are specific, detailed, and compelling
+        4. Highlighting the school's strengths and unique qualities
+        5. Providing guidance on required documentation and attachments
+        
+        Please be specific, professional, and thorough in your responses.
+        """
+        
+        messages = [{"role": "system", "content": system_prompt}]
+        messages.extend(history if history else [])
+        messages.append({"role": "user", "content": message})
+        
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=messages,
+            max_tokens=2000,
+            temperature=0.7,
+            stream=True
+        )
+
+        full_message = ""
+        for chunk in response:
+            if chunk.choices and chunk.choices[0].delta.content:
+                full_message += chunk.choices[0].delta.content
+                yield full_message
+
+        # Store chat history in database
+        if grant_id and school_id:
+            # Get or create application record
+            app_response = supabase.table('applications').select("id").eq('grant_id', grant_id).eq('school_id', school_id).execute()
+            if not app_response.data:
+                app_response = supabase.table('applications').insert({
+                    'grant_id': grant_id,
+                    'school_id': school_id,
+                    'status': 'Draft'
+                }).execute()
+            
+            application_id = app_response.data[0]['id']
+            
+            # Store messages
+            supabase.table('application_chat_history').insert([
+                {
+                    'application_id': application_id,
+                    'message_type': 'user',
+                    'content': message
+                },
+                {
+                    'application_id': application_id,
+                    'message_type': 'assistant',
+                    'content': full_message
+                }
+            ]).execute()
+
+    except Exception as e:
+        yield f"Error: {str(e)}"
+
+# Custom CSS for better UI
+custom_css = """
+.gradio-container {
+    max-width: 1200px !important;
+    margin: auto;
+    padding-top: 20px;
+}
+.main-header {
+    background-color: #2c3e50;
+    color: white;
+    padding: 1rem;
+    margin: -20px -20px 20px -20px;
+    text-align: center;
+}
+.grant-box {
+    border: 1px solid #ddd;
+    padding: 15px;
+    margin: 10px 0;
+    border-radius: 5px;
+    background-color: white;
+}
+.grant-box:hover {
+    box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+}
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+    # Session state for user
+    current_user_id = gr.State(None)
+    current_school_id = gr.State(None)
+    
     with gr.Tabs():
-        with gr.Tab("Chatbot"):
-            chat_interface = gr.ChatInterface(
-                fn=predict,
-                additional_inputs=[
-                    gr.Textbox("You are a helpful AI assistant.", label="System Prompt"),
-                    gr.Dropdown(["gpt-4o", "gpt-4o-mini"], label="Model"),
-                    gr.Slider(800, 4000, value=2000, label="Max Token"),
-                    gr.Slider(0, 1, value=0.7, label="Temperature"),
-                    gr.Slider(0, 1, value=0.95, label="Top P"),
-                ],
-                css="footer{display:none !important}"
+        # Entry Page
+        with gr.Tab("Entry"):
+            with gr.Box(elem_classes="main-header"):
+                gr.Markdown("# Welcome to GrantRight")
+                gr.Markdown("### Connecting Schools with Grant Opportunities")
+            
+            with gr.Row():
+                with gr.Column():
+                    create_profile_btn = gr.Button("Create School Profile", size="large")
+                with gr.Column():
+                    with gr.Group():
+                        login_username = gr.Textbox(label="Username")
+                        login_password = gr.Textbox(label="Password", type="password")
+                        login_btn = gr.Button("Log In", size="large")
+                        login_status = gr.Textbox(label="Status", interactive=False)
+            
+            login_btn.click(
+                fn=login,
+                inputs=[login_username, login_password],
+                outputs=[login_status, current_user_id]
             )
         
-        with gr.Tab("Table Viewer"):
-            gr.Markdown("# Supabase Table Viewer")
-            with gr.Row():
-                table_input = gr.Textbox(
-                    label="Table Name",
-                    placeholder="Enter the table name",
-                    value=""
+        # Create School Profile
+        with gr.Tab("Create Profile"):
+            gr.Markdown("# Create School Profile")
+            with gr.Group():
+                username = gr.Textbox(label="Username (Email)")
+                password = gr.Textbox(label="Password", type="password")
+                name = gr.Textbox(label="School Name")
+                with gr.Row():
+                    address = gr.Textbox(label="Address Line 1")
+                    city = gr.Textbox(label="City")
+                    state = gr.Dropdown(choices=["CA", "NY", "TX"], label="State")
+                    zip_code = gr.Textbox(label="ZIP Code")
+                with gr.Row():
+                    school_type = gr.Dropdown(
+                        choices=["Public", "Private", "Charter", "Nonprofit", "Other"],
+                        label="School Type"
+                    )
+                    educational_level = gr.Dropdown(
+                        choices=["K-12", "Higher Education", "Both"],
+                        label="Educational Level"
+                    )
+                with gr.Row():
+                    enrollment = gr.Number(label="Enrollment")
+                    title_i = gr.Checkbox(label="Title I Status")
+                    lunch_percentage = gr.Number(label="Free/Reduced Lunch Percentage")
+                email = gr.Textbox(label="Contact Email")
+                additional_info = gr.Textbox(label="Additional Information", lines=3)
+                submit_profile = gr.Button("Create Profile", size="large")
+                status = gr.Textbox(label="Status", interactive=False)
+            
+            submit_profile.click(
+                fn=sign_up_school,
+                inputs=[username, password, name, address, city, state, zip_code,
+                       school_type, educational_level, enrollment, title_i,
+                       lunch_percentage, email, additional_info],
+                outputs=[status]
+            )
+        
+        # Home Page (Grant Search)
+        with gr.Tab("Home"):
+            with gr.Box(elem_classes="main-header"):
+                gr.Markdown("# Find Your Perfect Grant Match")
+            
+            with gr.Group():
+                search_input = gr.Textbox(
+                    label="Enter information about school goals and grants you're interested in",
+                    lines=3,
+                    placeholder="Example: We're looking for STEM education grants to establish a robotics program..."
+                )
+                search_btn = gr.Button("Search Grants", size="large")
+                grants_output = gr.Dataframe(
+                    headers=["Title", "Provider", "Due_date", "Description", "Funding_amount", "Score"],
+                    label="Matching Grants",
+                    elem_classes="grant-box"
                 )
-                view_btn = gr.Button("View Table")
-            output_table = gr.Dataframe()
             
-            view_btn.click(
-                fn=fetch_table_data,
-                inputs=[table_input],
-                outputs=[output_table]
+            search_btn.click(
+                fn=search_grants,
+                inputs=[search_input, current_school_id],
+                outputs=[grants_output]
+            )
+        
+        # Grant Application Chat
+        with gr.Tab("Grant Chat"):
+            with gr.Box(elem_classes="main-header"):
+                gr.Markdown("# Grant Application Assistant")
+            
+            chat_interface = gr.ChatInterface(
+                fn=chat_with_ai,
+                title="Ask me anything about the grant application",
+                description="I can help you craft responses, understand requirements, and highlight your school's strengths.",
+                examples=[
+                    "What information should I include about our school's demographics?",
+                    "How should I describe our STEM program achievements?",
+                    "What supporting documents are typically required?",
+                    "How can I make our budget proposal more compelling?"
+                ]
             )
 
 if __name__ == "__main__":

schema.sql

@@ -0,0 +1,172 @@
+-- Enable the vector extension for embeddings
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Create schools table
+CREATE TABLE schools (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    user_id UUID REFERENCES auth.users(id),
+    name TEXT NOT NULL,
+    address_line1 TEXT,
+    city TEXT,
+    state TEXT,
+    zip_code TEXT,
+    school_type TEXT CHECK (school_type IN ('Public', 'Private', 'Charter', 'Nonprofit', 'Other')),
+    educational_level TEXT CHECK (educational_level IN ('K-12', 'Higher Education', 'Both')),
+    enrollment INTEGER,
+    title_i_status BOOLEAN DEFAULT FALSE,
+    free_reduced_lunch_percentage FLOAT,
+    contact_email TEXT,
+    additional_info TEXT,
+    embedding vector(1536),  -- For OpenAI embeddings
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW()),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW())
+);
+
+-- Create grants table
+CREATE TABLE grants (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    title TEXT NOT NULL,
+    url TEXT,
+    provider TEXT,
+    created_date TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW()),
+    due_date TIMESTAMP WITH TIME ZONE,
+    funding_amount DECIMAL,
+    contact_info TEXT,
+    description TEXT,
+    embedding vector(1536),  -- For OpenAI embeddings
+    requirements TEXT,       -- Specific requirements for the grant
+    eligibility TEXT,       -- Eligibility criteria
+    category TEXT[]         -- Array of categories (e.g., ['STEM', 'Education', 'Technology'])
+);
+
+-- Create applications table to track grant applications
+CREATE TABLE applications (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    school_id UUID REFERENCES schools(id),
+    grant_id UUID REFERENCES grants(id),
+    status TEXT CHECK (status IN ('Draft', 'Submitted', 'Under Review', 'Approved', 'Rejected')),
+    submission_date TIMESTAMP WITH TIME ZONE,
+    last_updated TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW()),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW()),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW()),
+    UNIQUE(school_id, grant_id)
+);
+
+-- Create application_chat_history table to store chat interactions
+CREATE TABLE application_chat_history (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    application_id UUID REFERENCES applications(id),
+    message_type TEXT CHECK (message_type IN ('user', 'assistant')),
+    content TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW())
+);
+
+-- Create saved_responses table to store drafted responses
+CREATE TABLE saved_responses (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    application_id UUID REFERENCES applications(id),
+    question_key TEXT,      -- Identifier for the question being answered
+    response_text TEXT,     -- The drafted response
+    last_edited TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW()),
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW())
+);
+
+-- Create application_documents table for uploaded files
+CREATE TABLE application_documents (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    application_id UUID REFERENCES applications(id),
+    document_type TEXT,     -- e.g., 'Budget', 'Timeline', 'Letter of Support'
+    file_name TEXT,
+    file_url TEXT,
+    uploaded_at TIMESTAMP WITH TIME ZONE DEFAULT TIMEZONE('utc'::text, NOW())
+);
+
+-- Add RLS (Row Level Security) policies
+ALTER TABLE schools ENABLE ROW LEVEL SECURITY;
+ALTER TABLE applications ENABLE ROW LEVEL SECURITY;
+ALTER TABLE application_chat_history ENABLE ROW LEVEL SECURITY;
+ALTER TABLE saved_responses ENABLE ROW LEVEL SECURITY;
+ALTER TABLE application_documents ENABLE ROW LEVEL SECURITY;
+
+-- Create policies
+CREATE POLICY "Users can view their own school profile"
+    ON schools FOR SELECT
+    USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can update their own school profile"
+    ON schools FOR UPDATE
+    USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can insert their own school profile"
+    ON schools FOR INSERT
+    WITH CHECK (auth.uid() = user_id);
+
+CREATE POLICY "Users can view their own applications"
+    ON applications FOR SELECT
+    USING (EXISTS (
+        SELECT 1 FROM schools
+        WHERE schools.id = applications.school_id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can create their own applications"
+    ON applications FOR INSERT
+    WITH CHECK (EXISTS (
+        SELECT 1 FROM schools
+        WHERE schools.id = applications.school_id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can view their own chat history"
+    ON application_chat_history FOR SELECT
+    USING (EXISTS (
+        SELECT 1 FROM applications
+        JOIN schools ON schools.id = applications.school_id
+        WHERE application_chat_history.application_id = applications.id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can insert chat messages"
+    ON application_chat_history FOR INSERT
+    WITH CHECK (EXISTS (
+        SELECT 1 FROM applications
+        JOIN schools ON schools.id = applications.school_id
+        WHERE application_chat_history.application_id = applications.id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can view their saved responses"
+    ON saved_responses FOR SELECT
+    USING (EXISTS (
+        SELECT 1 FROM applications
+        JOIN schools ON schools.id = applications.school_id
+        WHERE saved_responses.application_id = applications.id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can manage their saved responses"
+    ON saved_responses FOR ALL
+    USING (EXISTS (
+        SELECT 1 FROM applications
+        JOIN schools ON schools.id = applications.school_id
+        WHERE saved_responses.application_id = applications.id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can view their documents"
+    ON application_documents FOR SELECT
+    USING (EXISTS (
+        SELECT 1 FROM applications
+        JOIN schools ON schools.id = applications.school_id
+        WHERE application_documents.application_id = applications.id
+        AND schools.user_id = auth.uid()
+    ));
+
+CREATE POLICY "Users can manage their documents"
+    ON application_documents FOR ALL
+    USING (EXISTS (
+        SELECT 1 FROM applications
+        JOIN schools ON schools.id = applications.school_id
+        WHERE application_documents.application_id = applications.id
+        AND schools.user_id = auth.uid()
+    ));