Update app.py

app.py

@@ -1,234 +1,61 @@
-# app.py
-
-import streamlit as st
-import os
-import faiss
-import pickle
-from sentence_transformers import SentenceTransformer
-from groq import Groq
-from dotenv import load_dotenv
-import re # Import regular expressions for expand_query_with_llm_app
-
-# --- Configuration and Model Loading (best outside functions to use caching) ---
-@st.cache_resource # Important for caching large models and data
-def load_models_and_data():
-    # Load environment variables (if .env file is present in the Space)
-    load_dotenv()
-    groq_api_key_app = os.getenv("GROQ_API_KEY") # Ensure the key is available in the Space (see Step 3 of deployment)
-
-    # Paths to the index and chunks
-    output_folder = "faiss_index_bits" # Must be present in the HF Space
-    index_path = os.path.join(output_folder, "bits_tutor.index")
-    chunks_path = os.path.join(output_folder, "bits_chunks.pkl")
-
-    # Load FAISS Index
-    if not os.path.exists(index_path):
-        st.error(f"FAISS Index not found at: {index_path}")
-        return None, None, None, None
-    index_loaded = faiss.read_index(index_path)
-
-    # Load Chunks
-    if not os.path.exists(chunks_path):
-        st.error(f"Chunks file not found at: {chunks_path}")
-        return None, None, None, None
-    with open(chunks_path, "rb") as f:
-        chunks_loaded = pickle.load(f)
-
-    # Load Embedding Model
-    embedding_model_name_app = "Sahajtomar/German-semantic" 
-    embedding_model_loaded = SentenceTransformer(embedding_model_name_app)
-    
-    # Initialize Groq Client
-    if not groq_api_key_app:
-        st.error("GROQ_API_KEY not found. Please add it as a Secret in the Hugging Face Space settings.")
-        return None, None, None, None
-    groq_client_loaded = Groq(api_key=groq_api_key_app)
-
-    return index_loaded, chunks_loaded, embedding_model_loaded, groq_client_loaded
-
-# Load models and data when the app starts
-faiss_index, chunks_data, embedding_model, groq_client = load_models_and_data()
-
-# --- Functions from your notebook (slightly adapted for Streamlit) ---
-
-# retrieve_relevant_chunks (adapted for app)
-def retrieve_relevant_chunks_app(query, k=5):
-    if embedding_model is None or faiss_index is None or chunks_data is None:
-        return []
-    query_embedding = embedding_model.encode([query], convert_to_numpy=True)
-    distances, indices = faiss_index.search(query_embedding, k)
-    retrieved_chunks_data = [(chunks_data[i], distances[0][j]) for j, i in enumerate(indices[0])]
-    return retrieved_chunks_data
-
-# generate_answer (adapted for app - prompt remains German for German tutor functionality)
-def generate_answer_app(query, retrieved_chunks_data):
-    if groq_client is None:
-        return "Groq Client not initialized." # Developer-facing error
-    context = "\n\n".join([chunk_text for chunk_text, dist in retrieved_chunks_data])
-    # This prompt_template remains in German as it instructs the LLM for the German-speaking tutor
-    prompt_template = f"""Beantworte die folgende Frage ausschliesslich basierend auf dem bereitgestellten Kontext aus den Lehrmaterialien zur Business IT Strategie.
-Antworte auf Deutsch.
-
-Kontext:
-{context}
-
-Frage: {query}
-
-Antwort:
-"""
-    try:
-        chat_completion = groq_client.chat.completions.create(
-            messages=[{"role": "user", "content": prompt_template}],
-            model="llama3-70b-8192",
-            temperature=0.3,
-        )
-        return chat_completion.choices[0].message.content
-    except Exception as e:
-        # Developer-facing error
-        return f"Error during LLM request: {e}"
-
-# expand_query_with_llm (adapted for app - prompt for expansion remains German)
-def expand_query_with_llm_app(original_query, llm_client_app):
-    """
-    Expands a given user query using an LLM
-    to generate alternative formulations or relevant keywords.
-    Cleans the LLM's output.
-    (This function needs to use the llm_client_app passed to it)
-    """
-    if llm_client_app is None:
-        st.warning("LLM client for query expansion not initialized.")
-        return [original_query]
-        
-    # This prompt_template remains in German as it instructs the LLM for the German-speaking tutor's expansion
-    prompt_template_expansion = f"""Gegeben ist die folgende Nutzerfrage zum Thema "Business IT Strategie": "{original_query}"
-
-Bitte generiere 2-3 alternative Formulierungen dieser Frage ODER eine Liste von 3-5 sehr relevanten Schlüsselbegriffen/Konzepten, 
-die helfen würden, in einer Wissensdatenbank nach Antworten zu dieser Frage zu suchen.
-Formatiere die Ausgabe klar, z.B. als nummerierte Liste für alternative Fragen oder als kommaseparierte Liste für Schlüsselbegriffe.
-Gib NUR die alternativen Formulierungen oder die Schlüsselbegriffe aus. Keine Einleitungssätze.
-"""
-    try:
-        chat_completion = llm_client_app.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt_template_expansion,
-                }
-            ],
-            model="llama3-8b-8192", 
-            temperature=0.5,
-        )
-        expanded_terms_text = chat_completion.choices[0].message.content
-        
-        cleaned_queries = []
-        potential_queries = expanded_terms_text.split('\n')
-
-        for line in potential_queries:
-            line = line.strip()
-            line = re.sub(r"^\s*\d+\.\s*", "", line) 
-            line = re.sub(r"^\s*[-\*]\s*", "", line)
-            line = line.strip()
-
-            if not line or \
-               line.lower().startswith("here are") or \
-               line.lower().startswith("sicher, hier sind") or \
-               line.lower().startswith("alternative formulierungen:") or \
-               line.lower().startswith("*alternative formulierungen:**") or \
-               len(line) < 5: 
-                continue
-            cleaned_queries.append(line)
-        
-        if len(cleaned_queries) == 1 and ',' in cleaned_queries[0] and len(cleaned_queries[0].split(',')) > 1:
-             final_expanded_list = [term.strip() for term in cleaned_queries[0].split(',') if term.strip() and len(term.strip()) > 4]
-        else:
-            final_expanded_list = cleaned_queries
-
-        all_queries = [original_query]
-        for q_exp in final_expanded_list:
-            is_duplicate = False
-            for q_all in all_queries:
-                if q_all.lower() == q_exp.lower():
-                    is_duplicate = True
-                    break
-            if not is_duplicate:
-                all_queries.append(q_exp)
-        
-        return all_queries[:4] 
-
-    except Exception as e:
-        st.warning(f"Error during Query Expansion with LLM: {e}")
-        return [original_query]
-
-def retrieve_with_expanded_queries_app(original_query, llm_client_app, retrieve_func, k_per_expansion=2):
-    """
-    Performs Query Expansion and retrieves chunks for each expanded query.
-    Collects and de-duplicates the chunks.
-    (This function needs to use the llm_client_app passed to it)
-    """
-    expanded_queries = expand_query_with_llm_app(original_query, llm_client_app)
-    # st.write(f"Using the following queries for retrieval after expansion:") # For debugging
-    # for i, eq_query in enumerate(expanded_queries):
-    #     st.caption(f"  ExpQuery {i}: {eq_query}")
-
-    all_retrieved_chunks_data = []
-    for eq_query in expanded_queries:
-        retrieved_for_eq = retrieve_func(eq_query, k=k_per_expansion)
-        all_retrieved_chunks_data.extend(retrieved_for_eq) 
-
-    unique_chunks_dict = {}
-    for chunk_text, distance in all_retrieved_chunks_data:
-        if chunk_text not in unique_chunks_dict or distance < unique_chunks_dict[chunk_text]:
-            unique_chunks_dict[chunk_text] = distance
-    
-    sorted_unique_chunks_data = sorted(unique_chunks_dict.items(), key=lambda item: item[1])
-    
-    final_chunks_for_context = sorted_unique_chunks_data[:5] 
-    # st.write(f"\n{len(final_chunks_for_context)} unique chunks were selected for the context.") # For debugging
-    return final_chunks_for_context
-
-# --- Streamlit UI ---
-st.set_page_config(page_title="RAG BITS Tutor", page_icon="🎓") # Set page title and icon
-
-st.title("🎓 RAG Study Tutor for Business IT Strategy")
-st.write("Ask your questions about the content of the lecture notes and case studies (in German).")
-
-# User query input field (remains German for the user)
-user_query_streamlit = st.text_input("Deine Frage:", "")
-
-# Option to use query expansion
-use_expansion = st.checkbox("Use Query Expansion (may improve results for some questions)", value=True) # Default to True
-
-if user_query_streamlit:
-    if faiss_index and chunks_data and embedding_model and groq_client:
-        st.write("Searching for relevant information...")
-        
-        if use_expansion:
-            st.caption("Query expansion is active...")
-            retrieved_chunks = retrieve_with_expanded_queries_app(user_query_streamlit, groq_client, retrieve_relevant_chunks_app, k_per_expansion=2)
-        else:
-            st.caption("Direct retrieval...")
-            retrieved_chunks = retrieve_relevant_chunks_app(user_query_streamlit, k=3) # Number of chunks to retrieve
-
-        if retrieved_chunks:
-            # Optional display of retrieved context snippets (for debugging or transparency)
-            # with st.expander("Show retrieved context snippets"):
-            #     for i, (chunk, dist) in enumerate(retrieved_chunks):
-            #         st.caption(f"Chunk {i+1} (Distance: {dist:.2f})")
-            #         st.markdown(f"_{chunk[:200]}..._") # Displaying German chunk
-            #     st.divider()
-            
-            st.write("Generating answer...")
-            answer = generate_answer_app(user_query_streamlit, retrieved_chunks)
-            st.subheader("Tutor's Answer:") # UI element
-            st.markdown(answer) # Displaying German answer
-        else:
-            st.warning("No relevant information could be found for your query.") # UI element
-    else:
-        st.error("The application could not be initialized correctly. Please check the error messages above.") # UI element
-
-st.sidebar.header("About this Project") # UI element
-st.sidebar.info( # UI element
-    "This RAG application was developed as part of the 'AI Applications' module. "
-    "It uses Sentence Transformers for embeddings, FAISS for vector search, "
-    "and an LLM via Groq for answer generation."
-)
+# app.py
+
+import streamlit as st
+import os
+import faiss
+import pickle
+from sentence_transformers import SentenceTransformer
+from groq import Groq
+from dotenv import load_dotenv
+import re # Import regular expressions for expand_query_with_llm_app
+
+# --- Page Configuration (MUST BE THE FIRST STREAMLIT COMMAND) ---
+st.set_page_config(page_title="RAG BITS Tutor", page_icon="🎓") # Set page title and icon
+
+# --- Konfiguration und Modell-Laden (am besten ausserhalb von Funktionen, um Caching zu nutzen) ---
+@st.cache_resource # Wichtig für das Caching von grossen Modellen und Daten
+def load_models_and_data():
+    # Lade Umgebungsvariablen (falls .env Datei im Space vorhanden ist)
+    load_dotenv()
+    groq_api_key_app = os.getenv("GROQ_API_KEY") # Stelle sicher, dass der Key im Space verfügbar ist (siehe Schritt 3)
+
+    # Pfade zum Index und den Chunks
+    output_folder = "faiss_index_bits" # Muss im HF Space vorhanden sein
+    index_path = os.path.join(output_folder, "bits_tutor.index")
+    chunks_path = os.path.join(output_folder, "bits_chunks.pkl")
+
+    # Lade FAISS Index
+    if not os.path.exists(index_path):
+        st.error(f"FAISS Index nicht gefunden unter: {index_path}") # This is a Streamlit command
+        return None, None, None, None
+    index_loaded = faiss.read_index(index_path)
+
+    # Lade Chunks
+    if not os.path.exists(chunks_path):
+        st.error(f"Chunks-Datei nicht gefunden unter: {chunks_path}") # This is a Streamlit command
+        return None, None, None, None
+    with open(chunks_path, "rb") as f:
+        chunks_loaded = pickle.load(f)
+
+    # Lade Embedding-Modell
+    embedding_model_name_app = "Sahajtomar/German-semantic" 
+    embedding_model_loaded = SentenceTransformer(embedding_model_name_app)
+    
+    # Initialisiere Groq Client
+    if not groq_api_key_app:
+        st.error("GROQ_API_KEY nicht gefunden. Bitte im Hugging Face Space als Secret hinzufügen.") # This is a Streamlit command
+        return None, None, None, None
+    groq_client_loaded = Groq(api_key=groq_api_key_app)
+
+    return index_loaded, chunks_loaded, embedding_model_loaded, groq_client_loaded
+
+# Lade Modelle und Daten beim Start der App
+# Wichtig: Die Funktion load_models_and_data() verwendet st.error(), was ein Streamlit-Befehl ist.
+# Daher muss st.set_page_config() VOR dem ersten möglichen Aufruf von st.error() stehen.
+faiss_index, chunks_data, embedding_model, groq_client = load_models_and_data()
+
+# ... (Rest deines app.py Skripts bleibt gleich) ...
+
+# --- Streamlit UI (kommt nach load_models_and_data) ---
+st.title("🎓 RAG Study Tutor for Business IT Strategy") 
+# ... etc. ...