Update app.py

app.py

@@ -1,4 +1,4 @@
-import gradio as gr
+import streamlit as st
 import pandas as pd
 import json
 from sentence_transformers import SentenceTransformer, util
@@ -6,9 +6,13 @@ import torch
 import requests
 import re
 import urllib.parse
-import itertools # For generating pairs
+import itertools  # For generating pairs
 import os
-import io # Required for Google Drive upload
+import io         # Keep for potential future use (e.g., local download)
+import traceback  # Keep for error logging
+
+# -- Fix SSL error
+os.environ['REQUESTS_CA_BUNDLE'] = '/etc/ssl/certs/ca-certificates.crt'
 
 # --- Configuration ---
 CATEGORY_JSON_PATH = "categories.json"
@@ -19,104 +23,23 @@ MAX_TECHNOLOGIES_TO_SHOW = 8 # Max technologies relevant to the problem (selecte
 MAX_TECHNOLOGY_PAIRS_TO_SEARCH = 5 # Max pairs (from the relevant tech) to use for solution search
 MAX_SEARCH_REFERENCES_PER_PAIR = 5 # Max references from the API per pair
 SEARCH_API_URL = "https://ychkhan-ptt-endpoints.hf.space/search"
+# --- Removed Google Drive Config ---
 
-# --- Global Variables ---
-# To store pre-computed embeddings and data
-categories_data = {}
-category_names = []
-category_embeddings = None
-technologies_df = pd.DataFrame()
-technology_embeddings = None # Will store pre-computed embeddings for descriptions
-model = None
-
-
-###- GOOGLE DRIVE API
-# Check if running in an environment where Google Credentials are set
-# Use placeholder credentials if not found, but functionality will fail
-GOOGLE_CREDENTIALS = os.environ.get("GOOGLE_CREDENTIALS")
-FOLDER_ID = os.getenv("FOLDER_ID") # Optional: Folder ID for uploads
-
-# Only import Google libraries if credentials are potentially available
-if GOOGLE_CREDENTIALS:
-    try:
-        from google.oauth2 import service_account
-        from googleapiclient.discovery import build
-        from googleapiclient.http import MediaIoBaseDownload, MediaIoBaseUpload
-        GOOGLE_API_AVAILABLE = True
-        print("Google API libraries loaded.")
-    except ImportError:
-        print("Warning: Google API libraries not found. Google Drive upload will be disabled.")
-        GOOGLE_API_AVAILABLE = False
-else:
-    print("Warning: GOOGLE_CREDENTIALS environment variable not set. Google Drive upload will be disabled.")
-    GOOGLE_API_AVAILABLE = False
-    # Define dummy functions or handle calls gracefully if needed elsewhere
-    def create_new_file_in_drive(*args, **kwargs):
-         print("Google Drive upload skipped: Credentials not configured.")
-         return None
-
-
-if GOOGLE_API_AVAILABLE:
-    def create_new_file_in_drive(username, dataframe_to_upload, credentials_json_str, folder_id):
-        """Crée un nouveau fichier CSV dans Google Drive à partir d'un DataFrame Pandas."""
-        print(f"Attempting to upload results for user: {username}")
-        if not credentials_json_str:
-            print("Error: Google Credentials JSON string is empty.")
-            return None
-        if not folder_id:
-            print("Warning: Google Drive FOLDER_ID not specified. Upload might fail or go to root.")
-            # Decide if you want to default to root or fail
-            # return None # Option: Fail if no folder ID
-
-        try:
-            creds_dict = json.loads(credentials_json_str)
-        except json.JSONDecodeError as e:
-            print(f"Error decoding Google Credentials JSON: {e}")
-            return None
-
-        try:
-            # Charger les informations d'identification du compte de service
-            creds = service_account.Credentials.from_service_account_info(creds_dict)
-
-            # Construire le service API Drive
-            service = build('drive', 'v3', credentials=creds)
+# --- Global Variables (will be managed by Streamlit's caching) ---
+# These are loaded once via the cached function below
 
-            # Convertir le DataFrame en fichier CSV en mémoire
-            csv_buffer = io.BytesIO()
-            # Ensure UTF-8 encoding, especially with BOM for Excel compatibility if needed
-            dataframe_to_upload.to_csv(csv_buffer, index=False, sep=';', encoding='utf-8-sig')
-            csv_buffer.seek(0)
+# --- Removed Google Drive API Setup ---
 
-            # Créer les métadonnées du fichier
-            filename = f"rating-results-{username}.csv" # Consider adding a timestamp
-            file_metadata = {'name': filename}
-            if folder_id:
-                 file_metadata['parents'] = [folder_id]
+# --- Removed Google Drive Function ---
 
-            # Télécharger le fichier CSV sur Google Drive
-            media = MediaIoBaseUpload(csv_buffer, mimetype='text/csv', resumable=True)
-            file = service.files().create(body=file_metadata, media_body=media, fields='id, name, webViewLink').execute()
-
-            print(f"File '{file.get('name')}' created successfully in Google Drive. ID: {file.get('id')}")
-            print(f"Link: {file.get('webViewLink')}") # Optional: print link
-            return file.get('id')
-
-        except Exception as e:
-            print(f"Error during Google Drive upload: {e}")
-            # Consider more specific error handling (e.g., authentication errors)
-            return None
-
-###-
-
-
-# --- Load Data and Model (Load once at startup) ---
+# --- Load Data and Model (Cached) ---
+@st.cache_resource # Cache the model and embeddings
 def load_data_and_model():
-    global categories_data, category_names, category_embeddings
-    global technologies_df, technology_embeddings, model
-    print("Loading data and model...")
+    """Loads data files and the Sentence Transformer model once."""
+    print("Attempting to load data and model...")
     try:
         # Load Categories
-        with open(CATEGORY_JSON_PATH, 'r', encoding='utf-8') as f: # Specify encoding
+        with open(CATEGORY_JSON_PATH, 'r', encoding='utf-8') as f:
             categories_data = json.load(f)["Category"]
         category_names = list(categories_data.keys())
         category_texts = [f"{name}: {', '.join(keywords)}" for name, keywords in categories_data.items()]
@@ -124,15 +47,12 @@ def load_data_and_model():
 
         # Load Technologies
         technologies_df = pd.read_excel(TECHNOLOGY_EXCEL_PATH)
-        # Clean column names (remove leading/trailing spaces)
         technologies_df.columns = technologies_df.columns.str.strip()
-        # Ensure required columns exist
         if 'technology' not in technologies_df.columns or 'description' not in technologies_df.columns:
-             raise ValueError("Missing required columns 'technology' or 'description' in technologies.xlsx")
-        technologies_df['category'] = technologies_df.get('category', '').fillna('').astype(str) # Use .get for optional category
+            raise ValueError("Missing required columns 'technology' or 'description' in technologies.xlsx")
+        technologies_df['category'] = technologies_df.get('category', '').fillna('').astype(str)
         technologies_df['description_clean'] = technologies_df['description'].fillna('').astype(str)
-        # Add a unique ID if 'technology' name isn't unique or for easier embedding mapping
-        technologies_df['tech_id'] = technologies_df.index
+        technologies_df['tech_id'] = technologies_df.index # Use index as unique ID
         print(f"Loaded {len(technologies_df)} technologies.")
 
         # Load Sentence Transformer Model
@@ -141,281 +61,180 @@ def load_data_and_model():
 
         # Pre-compute category embeddings
         print("Computing category embeddings...")
-        category_embeddings = model.encode(category_texts, convert_to_tensor=True, show_progress_bar=True)
+        category_embeddings = model.encode(category_texts, convert_to_tensor=True)
         print("Category embeddings computed.")
 
         # Pre-compute technology description embeddings
         print("Computing technology description embeddings...")
         valid_descriptions = technologies_df['description_clean'].tolist()
-        technology_embeddings = model.encode(valid_descriptions, convert_to_tensor=True, show_progress_bar=True)
+        technology_embeddings = model.encode(valid_descriptions, convert_to_tensor=True)
         print(f"Technology description embeddings computed (shape: {technology_embeddings.shape}).")
 
+        return (model, categories_data, category_names, category_embeddings,
+                technologies_df, technology_embeddings)
+
     except FileNotFoundError as e:
+        st.error(f"ERROR: File not found - {e}. Please ensure '{CATEGORY_JSON_PATH}' and '{TECHNOLOGY_EXCEL_PATH}' are in the same directory as the script.")
         print(f"ERROR: File not found - {e}. Please ensure '{CATEGORY_JSON_PATH}' and '{TECHNOLOGY_EXCEL_PATH}' exist.")
-        raise e
+        return None # Indicate failure
     except Exception as e:
+        st.error(f"ERROR loading data or model: {e}")
         print(f"ERROR loading data or model: {e}")
-        raise e
-
-# --- Helper Functions ---
+        traceback.print_exc()
+        return None # Indicate failure
 
-def find_best_category(problem_description):
-    """
-    Finds the most relevant category using pre-computed embeddings.
-    This is now primarily for informational output.
-    """
+# --- Helper Functions (unchanged, use loaded_data) ---
+def find_best_category(problem_description, model, category_names, category_embeddings):
+    """Finds the most relevant category using pre-computed embeddings."""
     if not problem_description or not category_names or category_embeddings is None:
-        return None, 0.0
+        return None, 0.0, False
     try:
         problem_embedding = model.encode(problem_description, convert_to_tensor=True)
         cosine_scores = util.pytorch_cos_sim(problem_embedding, category_embeddings)[0]
         best_score, best_idx = torch.max(cosine_scores, dim=0)
-        # Return the best category regardless of threshold, but indicate confidence
         best_category_name = category_names[best_idx.item()]
         best_category_score = best_score.item()
-
-        # Decide if the match is confident enough to strongly suggest
         is_confident = best_category_score >= CATEGORY_SIMILARITY_THRESHOLD
-
         return best_category_name, best_category_score, is_confident
-
     except Exception as e:
         print(f"Error during category finding: {e}")
         return None, 0.0, False
 
-# --- MODIFIED FUNCTION ---
-def find_relevant_technologies(problem_description):
-    """
-    Calculates similarity between the problem description and ALL technology
-    descriptions using pre-computed embeddings, sorts, and returns the top results.
-    Category is no longer used for filtering here.
-    """
+def find_relevant_technologies(problem_description, model, technologies_df, technology_embeddings):
+    """Calculates similarity between the problem and ALL technology descriptions."""
     all_tech_data = []
     if technologies_df.empty or technology_embeddings is None or not problem_description:
         print("Warning: Technologies DF, embeddings, or problem description missing.")
         return pd.DataFrame()
-
     try:
         problem_embedding = model.encode(problem_description, convert_to_tensor=True)
+        # Efficiently calculate all similarities at once
+        cosine_scores = util.pytorch_cos_sim(problem_embedding, technology_embeddings)[0]
 
-        # Iterate through ALL technologies
-        for index, row in technologies_df.iterrows():
-            tech_id = row['tech_id'] # Use the pre-assigned index/id
-
-            # Ensure tech_id is within the bounds of the embeddings tensor
-            if tech_id >= technology_embeddings.shape[0]:
-                print(f"Warning: tech_id {tech_id} is out of bounds for technology_embeddings (shape: {technology_embeddings.shape}). Skipping.")
-                continue
-
-            # Retrieve pre-computed embedding using tech_id
-            tech_embedding = technology_embeddings[tech_id]
-
-            # Calculate similarity score with the problem
-            # Ensure embeddings are compatible (e.g., both are single vectors)
-            if problem_embedding.ndim == 1:
-                 problem_embedding_exp = problem_embedding.unsqueeze(0) # Add batch dimension if needed
-            else:
-                 problem_embedding_exp = problem_embedding
-
-            if tech_embedding.ndim == 1:
-                 tech_embedding_exp = tech_embedding.unsqueeze(0)
-            else:
-                 tech_embedding_exp = tech_embedding
-
-
-            similarity_score = util.pytorch_cos_sim(problem_embedding_exp, tech_embedding_exp)[0][0].item()
-
-            # Store the original row data and the similarity score
-            all_tech_data.append({'data': row.to_dict(), 'similarity_score_problem': similarity_score})
-
-
-        # Sort technologies based on similarity to the problem (descending)
-        all_tech_data.sort(key=lambda item: item['similarity_score_problem'], reverse=True)
-
-        if not all_tech_data:
-            print("No technologies found or scored.")
-            return pd.DataFrame()
-
-        # Create DataFrame from the top N results
-        # Extract the 'data' part (which is a dict) for DataFrame creation
-        top_tech_rows = [item['data'] for item in all_tech_data[:MAX_TECHNOLOGIES_TO_SHOW]]
-        # Extract the corresponding scores
-        top_tech_scores = [item['similarity_score_problem'] for item in all_tech_data[:MAX_TECHNOLOGIES_TO_SHOW]]
-
-        if not top_tech_rows:
-             return pd.DataFrame()
-
-        relevant_df = pd.DataFrame(top_tech_rows)
-        # Important: Ensure the index aligns if you add the score column later
-        relevant_df = relevant_df.reset_index(drop=True)
-        relevant_df['similarity_score_problem'] = top_tech_scores # Add scores as a new column
+        # Add scores to the dataframe temporarily
+        temp_df = technologies_df.copy()
+        temp_df['similarity_score_problem'] = cosine_scores.cpu().numpy() # Move scores to CPU and numpy
 
+        # Sort by similarity and get top N
+        relevant_df = temp_df.nlargest(MAX_TECHNOLOGIES_TO_SHOW, 'similarity_score_problem')
 
         # print(f"Top relevant technologies DF head:\n{relevant_df.head()}") # Debug print
-        return relevant_df # Return the top N technologies based on problem similarity
+        return relevant_df
 
     except Exception as e:
         print(f"Error during technology finding/scoring: {e}")
-        import traceback
         traceback.print_exc() # Print full traceback for debugging
         return pd.DataFrame()
 
 
-def find_top_technology_pairs(relevant_technologies_df):
-    """
-    Calculates similarity between pairs of the identified relevant technologies
-    (which were selected based on problem similarity) and returns the top pairs.
-    Uses pre-computed embeddings.
-    """
+def find_top_technology_pairs(relevant_technologies_df, technology_embeddings):
+    """Calculates similarity between pairs of relevant technologies."""
     if relevant_technologies_df.empty or len(relevant_technologies_df) < 2 or technology_embeddings is None:
-        # print("Warning: Not enough relevant technologies (<2) or embeddings missing for pairing.")
         return []
 
     pairs_with_scores = []
-    # Use tech_id (which should be the original index) to reliably get embeddings
-    # Check if 'tech_id' column exists in the relevant_technologies_df
     if 'tech_id' not in relevant_technologies_df.columns:
-         print("Error: 'tech_id' column missing in relevant_technologies_df. Cannot proceed with pairing.")
-         return []
+        print("Error: 'tech_id' column missing in relevant_technologies_df.")
+        return []
 
     tech_ids = relevant_technologies_df['tech_id'].tolist()
-    # Create a mapping from tech_id back to the technology name in the relevant subset for easy lookup
     tech_id_to_name = pd.Series(relevant_technologies_df['technology'].values, index=relevant_technologies_df['tech_id']).to_dict()
 
-
-    # Generate unique pairs of tech_ids from the relevant list
     for id_a, id_b in itertools.combinations(tech_ids, 2):
         try:
-            # Retrieve pre-computed embeddings using the original index (tech_id)
-            # Add boundary checks again just in case
+            # Boundary checks
             if id_a >= technology_embeddings.shape[0] or id_b >= technology_embeddings.shape[0]:
-                 print(f"Warning: tech_id {id_a} or {id_b} out of bounds for embeddings. Skipping pair.")
-                 continue
+                print(f"Warning: tech_id {id_a} or {id_b} out of bounds. Skipping pair.")
+                continue
 
             embedding_a = technology_embeddings[id_a]
             embedding_b = technology_embeddings[id_b]
 
-            # Ensure embeddings are 1D or correctly shaped for cos_sim
-            if embedding_a.ndim > 1: embedding_a = embedding_a.squeeze()
-            if embedding_b.ndim > 1: embedding_b = embedding_b.squeeze()
-            if embedding_a.ndim == 0 or embedding_b.ndim == 0: # Check if squeeze resulted in 0-dim tensor
-                 print(f"Warning: Invalid embedding dimension after squeeze for pair ({id_a}, {id_b}). Skipping.")
-                 continue
-
             # Calculate inter-technology similarity
-            inter_similarity = util.pytorch_cos_sim(embedding_a, embedding_b)[0][0].item()
+            inter_similarity = util.pytorch_cos_sim(embedding_a.unsqueeze(0), embedding_b.unsqueeze(0))[0][0].item()
 
-            # Get technology names using the mapping created earlier
             tech_name_a = tech_id_to_name.get(id_a, f"Unknown Tech (ID:{id_a})")
             tech_name_b = tech_id_to_name.get(id_b, f"Unknown Tech (ID:{id_b})")
 
-            # Clean names for display/use
             clean_tech_name_a = re.sub(r'^- Title\s*:\s*', '', str(tech_name_a)).strip()
             clean_tech_name_b = re.sub(r'^- Title\s*:\s*', '', str(tech_name_b)).strip()
 
             pairs_with_scores.append(((clean_tech_name_a, clean_tech_name_b), inter_similarity))
 
-        except IndexError:
-            print(f"Warning: Could not find pre-computed embedding for index {id_a} or {id_b}. Skipping pair.")
-            continue
         except Exception as e:
             print(f"Error calculating similarity for pair ({id_a}, {id_b}): {e}")
-            import traceback
             traceback.print_exc()
             continue
 
-
-    # Sort pairs by inter-similarity score (descending)
     pairs_with_scores.sort(key=lambda item: item[1], reverse=True)
-
-    # Return the top K pairs
-    # print(f"Top pairs identified: {pairs_with_scores[:MAX_TECHNOLOGY_PAIRS_TO_SEARCH]}") # Debug print
-    return pairs_with_scores[:MAX_TECHNOLOGY_PAIRS_TO_SEARCH]
+    pairs_with_scores_min_max = []
+    pairs_with_scores_min_max.extend(pairs_with_scores[:MAX_TECHNOLOGY_PAIRS_TO_SEARCH-2])
+    pairs_with_scores_min_max.extend(pairs_with_scores[MAX_TECHNOLOGY_PAIRS_TO_SEARCH-3:])
+    return pairs_with_scores_min_max
 
 
 def search_solutions_for_pairs(problem_description, top_pairs):
-    """
-    Searches for solutions/patents using pairs of technologies via the API.
-    """
-    results = {} # Store results keyed by the pair tuple
-    if not top_pairs or not problem_description:
-        # Provide a more informative message if no pairs were generated
-        if not top_pairs:
-             return "No relevant technology pairs were identified (need at least 2 relevant technologies). Cannot search for solutions.\n"
-        else: # problem_description must be missing
-             return "Problem description is missing. Cannot search for solutions.\n"
-
+    """Searches for solutions/patents using pairs of technologies via the API."""
+    results = {}
+    if not top_pairs:
+        # Return value modified for clarity
+        return "No relevant technology pairs were identified (need at least 2 relevant technologies). Cannot search for solutions.\n", results
+    if not problem_description:
+        return "Problem description is missing. Cannot search for solutions.\n", results
 
     headers = {'accept': 'application/json'}
+    api_output = f"### Potential Solutions & Patents (Found using Top {len(top_pairs)} Technology Pairs):\n\n"
 
     for pair_info in top_pairs:
         pair_names, pair_score = pair_info
         tech_a_name, tech_b_name = pair_names
+        if not tech_a_name or not tech_b_name: continue
 
-        if not tech_a_name or not tech_b_name: continue # Skip if names are invalid
-
-        # Construct query for the API
-        # Focus query on tech combination and context (patent/research)
-        # Keep problem description out of the API query unless the API is designed for it
-        # query = f'"{tech_a_name}" AND "{tech_b_name}" patent OR research paper OR application'
-        # More targeted query:
-        query = f'research paper or patent on {tech_a_name} and {tech_b_name} of {problem_description}' # Use snippet of problem
-
+        query = f'research paper or patent on {tech_a_name} and {tech_b_name} related to {problem_description[:100]}...' # Keep query focused
         params = {
             'query': query,
             'max_references': MAX_SEARCH_REFERENCES_PER_PAIR
         }
-        encoded_params = urllib.parse.urlencode(params, quote_via=urllib.parse.quote) # Ensure proper encoding
-        full_url = f"{SEARCH_API_URL}?{encoded_params}"
-
-        pair_key = f"{tech_a_name} + {tech_b_name}" # Key for storing results
-        print(f"Calling API for pair ({pair_key}): POST {SEARCH_API_URL} with query: {query}") # Log query separately
+        pair_key = f"{tech_a_name} + {tech_b_name}"
+        print(f"Calling API for pair ({pair_key}): POST {SEARCH_API_URL} with query snippet: {query[:100]}...")
 
         try:
-            # Using POST as originally indicated, send params in the body (common for longer queries)
-            # If API expects GET, change to requests.get(full_url, headers=headers)
-            response = requests.post(SEARCH_API_URL, headers=headers, params=params, timeout=45) # Increased timeout
-            response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
-
-            try:
-                 api_response = response.json()
-            except json.JSONDecodeError:
-                 err_msg = f"API Error: Invalid JSON response. Status: {response.status_code}, Response text: {response.text[:200]}"
-                 print(f"Error decoding JSON response for pair '{pair_key}'. {err_msg}")
-                 results[pair_key] = {"score": pair_score, "error": err_msg}
-                 continue # Skip to next pair
+            response = requests.post(SEARCH_API_URL, headers=headers, params=params, timeout=45)
+            response.raise_for_status()
+            api_response = response.json() # Assume JSON response
 
             search_results = []
             # --- Adapt based on actual API response structure ---
             if isinstance(api_response, list):
-                search_results = api_response # Assumes list of dicts like {'title': '...', 'url': '...'}
-            elif isinstance(api_response, dict) and 'results' in api_response and isinstance(api_response['results'], list):
-                search_results = api_response['results']
-            elif isinstance(api_response, dict) and 'references' in api_response and isinstance(api_response['references'], list):
-                 # Handle potential alternative key name
-                 search_results = api_response['references']
+                search_results = api_response
+            elif isinstance(api_response, dict):
+                 # Try common keys for results lists
+                 if 'results' in api_response and isinstance(api_response.get('results'), list):
+                     search_results = api_response['results']
+                 elif 'references' in api_response and isinstance(api_response.get('references'), list):
+                     search_results = api_response['references']
+                 elif 'links' in api_response and isinstance(api_response.get('links'), list): # Another possibility
+                     search_results = api_response['links']
+                 else: # Check if the dict itself contains title/url
+                     if 'title' in api_response and ('url' in api_response or 'link' in api_response):
+                          search_results = [api_response] # Wrap it in a list
+                     else:
+                          print(f"Warning: Unexpected API response format for pair '{pair_key}'. Response keys: {list(api_response.keys())}")
             else:
-                print(f"Warning: Unexpected API response format for pair '{pair_key}'. Response: {api_response}")
-                # Attempt to extract links if possible, otherwise mark as no results
-                # This part needs adjustment based on observed API responses
-                search_results = [] # Default to empty if format unknown
-
+                 print(f"Warning: Unexpected API response type for pair '{pair_key}'. Type: {type(api_response)}")
             # --- End adaptation ---
 
             valid_links = []
             for r in search_results:
-                 if isinstance(r, dict):
-                     title = r.get('title', 'N/A')
-                     url = r.get('url', r.get('link')) # Check for 'url' or 'link'
-                     if url and isinstance(url, str) and url.startswith(('http://', 'https://')):
-                          valid_links.append({'title': title, 'link': url})
-                     elif url:
-                          print(f"Warning: Invalid or missing URL for result '{title}' in pair '{pair_key}': {url}")
-
-            results[pair_key] = {
-                "score": pair_score, # Store pair score for context
-                "links": valid_links
-            }
+                if isinstance(r, dict):
+                    title = r.get('title', 'N/A')
+                    url = r.get('url', r.get('link')) # Check for 'url' or 'link'
+                    if url and isinstance(url, str) and url.startswith(('http://', 'https://')):
+                         valid_links.append({'title': title, 'link': url})
+                    elif url:
+                         print(f"Warning: Invalid or missing URL for result '{title}' in pair '{pair_key}': {url}")
+
+            results[pair_key] = {"score": pair_score, "links": valid_links}
 
         except requests.exceptions.Timeout:
             print(f"Error: API call timed out for pair '{pair_key}'")
@@ -426,55 +245,57 @@ def search_solutions_for_pairs(problem_description, top_pairs):
         except requests.exceptions.RequestException as e:
             print(f"Error calling search API for pair '{pair_key}': {e}")
             results[pair_key] = {"score": pair_score, "error": f"API Request Error: {e}"}
+        except json.JSONDecodeError:
+            err_msg = f"API Error: Invalid JSON response. Status: {response.status_code}, Response text: {response.text[:200]}"
+            print(f"Error decoding JSON response for pair '{pair_key}'. {err_msg}")
+            results[pair_key] = {"score": pair_score, "error": err_msg}
         except Exception as e:
             err_msg = f"Unexpected Error during API call: {e}"
             print(f"Unexpected error during API call for pair '{pair_key}': {e}")
-            import traceback
             traceback.print_exc()
             results[pair_key] = {"score": pair_score, "error": err_msg}
 
-
     # Format results for display
-    output = f"### Potential Solutions & Patents (Found using Top {len(results)} Technology Pairs):\n\n"
     if not results:
-        output += "No search results could be retrieved from the API for the generated technology pairs."
-        return output
+        api_output += "No search results could be retrieved from the API for the generated technology pairs."
+        return api_output, results # Return formatted string and raw results dict
 
-    # Display results in the order they were searched (already sorted by pair score)
     for pair_key, search_data in results.items():
         pair_score = search_data.get('score', 0.0)
-        output += f"**For Technology Pair: {pair_key}** (Inter-Similarity Score: {pair_score:.3f})\n" # More precision
-
+        api_output += f"**For Technology Pair: {pair_key}** (Inter-Similarity Score: {pair_score:.3f})\n"
         if "error" in search_data:
-            output += f"- *Search failed: {search_data['error']}*\n"
+            api_output += f"- *Search failed: {search_data['error']}*\n"
         elif "links" in search_data:
             links = search_data["links"]
             if links:
                 for link_info in links:
-                     # Ensure title is a string before replacing
-                     title_str = str(link_info.get('title', 'N/A'))
-                     # Basic sanitization for Markdown display
-                     title_sanitized = title_str.replace('[','(').replace(']',')')
-                     output += f"- [{title_sanitized}]({link_info.get('link', '#')})\n"
+                    title_str = str(link_info.get('title', 'N/A'))
+                    title_sanitized = title_str.replace('[','(').replace(']',')')
+                    api_output += f"- [{title_sanitized}]({link_info.get('link', '#')})\n"
             else:
-                output += "- *No specific results found by the API for this technology pair.*\n"
+                api_output += "- *No specific results found by the API for this technology pair.*\n"
         else:
-             output += "- *Unknown search result state.*\n"
-        output += "\n" # Add space between pairs
+            api_output += "- *Unknown search result state.*\n"
+        api_output += "\n"
 
-    return output
+    return api_output, results # Return formatted string and raw results dict
 
 # --- Main Processing Function ---
-def process_problem(problem_description):
+def process_problem(problem_description, loaded_data):
     """
-    Main function called by Gradio interface. Orchestrates the process.
+    Main function called by Streamlit interface. Orchestrates the process.
+    Returns the formatted output string AND the relevant technologies DataFrame.
     """
-    print(f"\n--- Processing request for: '{problem_description[:100]}...' ---") # Log start
-    if not problem_description:
-        return "Please enter a problem description."
+    print(f"\n--- Processing request for: '{problem_description[:100]}...' ---")
+    if not loaded_data:
+         # This case should ideally be handled before calling process_problem
+         return "Error: Model and data not loaded.", pd.DataFrame()
 
-    # 1. Categorize Problem (Informational)
-    category_name, cat_score, is_confident = find_best_category(problem_description)
+    (model, categories_data, category_names, category_embeddings,
+     technologies_df, technology_embeddings) = loaded_data
+
+    # 1. Categorize Problem
+    category_name, cat_score, is_confident = find_best_category(problem_description, model, category_names, category_embeddings)
     if category_name:
         confidence_text = "(Confident Match)" if is_confident else "(Possible Match)"
         category_output = f"**Best Matching Category:** {category_name} {confidence_text} (Similarity Score: {cat_score:.3f})"
@@ -482,110 +303,127 @@ def process_problem(problem_description):
         category_output = "**Could not identify a matching category.**"
     print(f"Category identified: {category_name} (Score: {cat_score:.3f}, Confident: {is_confident})")
 
-    # 2. Find Relevant Technologies (relative to problem, across ALL categories)
-    relevant_technologies_df = find_relevant_technologies(problem_description)
+    # 2. Find Relevant Technologies
+    relevant_technologies_df = find_relevant_technologies(problem_description, model, technologies_df, technology_embeddings)
     print(f"Found {len(relevant_technologies_df)} relevant technologies based on problem similarity.")
-
     tech_output = ""
     if not relevant_technologies_df.empty:
         tech_output += f"### Top {len(relevant_technologies_df)} Most Relevant Technologies (selected based on similarity to your problem):\n\n"
+        # Create a list for display, keeping relevant data
+        display_tech_list = []
         for _, row in relevant_technologies_df.iterrows():
-            tech_name = re.sub(r'^- Title\s*:\s*', '', str(row.get('technology', 'N/A'))).strip()
-            problem_relevance = row.get('similarity_score_problem', 0.0)
-            tech_output += f"- **{tech_name}** (Problem Relevance: {problem_relevance:.3f})\n"
-            original_cats = str(row.get('category', 'Unknown')).strip()
-            if original_cats:
-                tech_output += f"  *Original Category listed as: {original_cats}*\n"
-        tech_output += "\n---\n" # Add separator
-    else:
-         tech_output = "Could not identify any relevant technologies based on the problem description.\n\n---\n"
+             tech_name = re.sub(r'^- Title\s*:\s*', '', str(row.get('technology', 'N/A'))).strip()
+             problem_relevance = row.get('similarity_score_problem', 0.0)
+             original_cats = str(row.get('category', 'Unknown')).strip()
 
+             tech_output += f"- **{tech_name}** (Problem Relevance: {problem_relevance:.3f})\n"
+             if original_cats:
+                 tech_output += f"  *Original Category listed as: {original_cats}*\n"
 
-    # 3. Find Top Technology Pairs (based on inter-similarity among the relevant ones)
-    top_pairs = find_top_technology_pairs(relevant_technologies_df)
-    print(f"Identified {len(top_pairs)} top technology pairs for searching.")
+        tech_output += "\n---\n"
+    else:
+        tech_output = "Could not identify any relevant technologies based on the problem description.\n\n---\n"
 
+    # 3. Find Top Technology Pairs
+    top_pairs = find_top_technology_pairs(relevant_technologies_df, technology_embeddings)
+    print(f"Identified {len(top_pairs)} top technology pairs for searching.")
     pairs_output = ""
     if top_pairs:
         pairs_output += f"### Top {len(top_pairs)} Technology Pairs (selected from the relevant technologies above, based on their inter-similarity):\n\n"
         for pair_names, score in top_pairs:
             pairs_output += f"- **{pair_names[0]} + {pair_names[1]}** (Inter-Similarity: {score:.3f})\n"
         pairs_output += "\n---\n"
-    # Note: The "else" case message will be added during final output assembly
+    # No 'else' needed here, handled in final assembly
 
     # 4. Search for Solutions using the Top Pairs
-    solution_output = search_solutions_for_pairs(problem_description, top_pairs)
+    solution_output_text, _ = search_solutions_for_pairs(problem_description, top_pairs) # Ignore raw results dict here
     print("API search for solutions completed.")
 
-    # 5. Combine Outputs for Gradio --- CORRECTED SECTION ---
+    # 5. Combine Outputs
     final_output = (
         f"## Analysis Results for: \"{problem_description[:150]}...\"\n\n"
         f"{category_output}\n\n"
         f"{tech_output}"
-        # Intentionally left blank line above for structure
     )
-
-    # Add the pairs section conditionally - This avoids the backslash issue
     if top_pairs:
-        final_output += pairs_output # pairs_output already contains formatting and separators
+        final_output += pairs_output
     else:
-        # Add the "no pairs" message directly here
-        final_output += "No technology pairs identified to search with.\n\n---\n"
+        final_output += "No technology pairs identified (need >= 2 relevant technologies to form pairs).\n\n---\n"
 
-    # Add the solution output
-    final_output += solution_output
-    # --- END OF CORRECTION ---
+    final_output += solution_output_text
 
     print("--- Processing finished ---")
-    return final_output
-
-# --- Create Gradio Interface ---
-print("Setting up Gradio interface...")
-
-# Load data only once when the script starts
-try:
-    load_data_and_model()
-    interface_enabled = True
-except Exception as e:
-    print(f"FATAL: Failed to initialize application. Error: {e}")
-    interface_enabled = False
-
-# Only create interface if initialization succeeded
-if interface_enabled:
-    iface = gr.Interface(
-        fn=process_problem,
-        inputs=gr.Textbox(lines=5, label="Enter Technical Problem Description", placeholder="Describe your technical challenge or requirement here... e.g., 'Develop low-latency communication protocols for 6G networks'"),
-        outputs=gr.Markdown(label="Analysis and Potential Solutions"),
-        title="Technical Problem Analyzer v4 (Cross-Category Relevance)",
-        description=(
-            "Enter a technical problem. The app:\n"
-            "1. Identifies the best matching **category** (for informational purposes).\n"
-            "2. Finds the **most relevant technologies** based *directly on your problem description* (across all categories).\n"
-            "3. Identifies **promising pairs** among these relevant technologies based on their similarity to each other.\n"
-            "4. Searches for **patents/research** using these pairs via an external API."
-        ),
-        examples=[
-            ["How can I establish reliable communication between low-orbit satellites for continuous global monitoring?"],
-            ["Need a system to automatically detect anomalies in sensor data from industrial machinery using machine learning."],
-            ["Develop low-latency communication protocols for 6G networks"],
-            ["Design efficient routing algorithms for large scale mesh networks in smart cities"],
-            ["Create biodegradable packaging material from agricultural waste"], # Example crossing categories potentially
-            ["Develop a method for real-time traffic prediction using heterogeneous data sources"]
-        ],
-        allow_flagging='never',
-        # Add theme for better visuals if desired
-        # theme=gr.themes.Soft()
+    # Return both the formatted text and the DataFrame (might be useful later)
+    return final_output, relevant_technologies_df
+
+# --- Streamlit UI ---
+def main():
+    st.set_page_config(page_title="Technical Problem Analyzer", layout="wide")
+    st.title("🔧 Technical Problem Analyzer v4 (Local Streamlit)")
+
+    st.markdown(
+        """
+        Enter a technical problem. The app will:
+        1. Identify the best matching **category** (for informational purposes).
+        2. Find the **most relevant technologies** based *directly on your problem description*.
+        3. Identify **promising pairs** among these relevant technologies based on their similarity.
+        4. Search for **patents/research** using these pairs via an external API.
+        """
     )
-else:
-    # Provide a dummy interface indicating failure
-     def error_fn():
-          return "Application failed to initialize. Please check the logs for errors (e.g., missing files or model issues)."
-     iface = gr.Interface(fn=error_fn, inputs=[], outputs=gr.Markdown(), title="Initialization Failed")
 
+    # Load data and model (cached)
+    loaded_data = load_data_and_model()
+
+    if loaded_data is None:
+        st.error("Application initialization failed. Check logs for details.")
+        st.stop() # Stop execution if loading failed
+
+    # Example problems (optional)
+    st.subheader("Example Problems:")
+    examples = [
+        "How can I establish reliable communication between low-orbit satellites for continuous global monitoring?",
+        "Need a system to automatically detect anomalies in sensor data from industrial machinery using machine learning.",
+        "Develop low-latency communication protocols for 6G networks",
+        "Design efficient routing algorithms for large scale mesh networks in smart cities",
+        "Create biodegradable packaging material from agricultural waste",
+        "Develop a method for real-time traffic prediction using heterogeneous data sources"
+    ]
+    selected_example = st.selectbox("Select an example or enter your own below:", [""] + examples)
+
+
+    # User input
+    problem_description_input = st.text_area(
+        "Enter Technical Problem Description:",
+        height=150,
+        placeholder="Describe your technical challenge or requirement here...",
+        value=selected_example # Use selected example if chosen
+    )
+
+    # Button to trigger analysis
+    analyze_button = st.button("Analyze Problem")
+
+    if analyze_button and problem_description_input:
+        with st.spinner("Analyzing problem and searching for solutions..."):
+            # Run the main processing function
+            analysis_output, relevant_tech_df = process_problem(problem_description_input, loaded_data)
+
+            # Display results
+            st.markdown("---") # Separator
+            st.markdown(analysis_output) # Display formatted text results
+
+            # --- Removed Google Drive Upload Section ---
+            # You could potentially add other actions here using relevant_tech_df,
+            # like displaying it as a table or offering a local download.
+            # Example: Display relevant technologies table
+            if not relevant_tech_df.empty:
+                st.markdown("---")
+                st.subheader("Relevant Technologies Data")
+                st.dataframe(relevant_tech_df[['technology', 'description', 'category', 'similarity_score_problem']])
+
+
+    elif analyze_button and not problem_description_input:
+        st.warning("Please enter a problem description.")
 
-# --- Launch the App ---
+# --- Run the App ---
 if __name__ == "__main__":
-    print("Launching Gradio app...")
-    # Consider adding share=True for public link if running on appropriate infra
-    # debug=True can be helpful during development
-    iface.launch()
+    main()