Update app.py

app.py

@@ -1,150 +1,99 @@
 import gradio as gr
-import torch
-from transformers import AutoTokenizer, AutoModel
-from sklearn.neighbors import NearestNeighbors
-import numpy as np
-import re
 import os
+import re
 import requests
 
 # Configuration
-HF_MODEL = "HuggingFaceH4/zephyr-7b-beta"
+HF_TOKEN = os.getenv("HF_TOKEN", "").strip()  # Make sure your token is set in the Space secrets
+HF_MODEL = "HuggingFaceH4/zephyr-7b-beta"      # Example model; change if you use another
 HF_API_URL = f"https://api-inference.huggingface.co/models/{HF_MODEL}"
-headers = {"Authorization": f"Bearer {os.getenv('HF_TOKEN', '').strip()}"}
-FILES = [f"Main{i}.txt" for i in range(1, 3)]
-CHUNK_SIZE = 500
-overlap = 100
-
-# New: Pure Python sentence chunking (no spaCy needed)
-def smart_chunk_text(text, chunk_size, overlap):
-    sentences = re.split(r'(?<=[.!?])\s+', text.strip())
-    chunks = []
-    current_chunk = []
-    total_len = 0
-    i = 0
-
-    while i < len(sentences):
-        if total_len + len(sentences[i]) <= chunk_size:
-            current_chunk.append(sentences[i])
-            total_len += len(sentences[i])
-            i += 1
-        else:
-            chunks.append(" ".join(current_chunk))
-            if overlap > 0:
-                overlap_len = 0
-                j = len(current_chunk) - 1
-                while j >= 0 and overlap_len < overlap:
-                    overlap_len += len(current_chunk[j])
-                    j -= 1
-                i = max(i - (len(current_chunk) - j - 1), 0)
-            total_len = 0
-            current_chunk = []
-
-    if current_chunk:
-        chunks.append(" ".join(current_chunk))
 
-    return chunks
-
-# Load and process text files
-def process_text_files(file_list, chunk_size=CHUNK_SIZE):
-    combined_chunks = []
-    for file in file_list:
-        try:
-            with open(file, encoding="utf-8") as f:
-                content = f.read()
-        except Exception as e:
-            print(f"❌ Error reading {file}: {e}")
-            continue
+headers = {"Authorization": f"Bearer {HF_TOKEN}"}
 
+# Load knowledge base from .txt files
+def load_text_files(file_list):
+    knowledge = ""
+    for file_name in file_list:
         try:
-            plain_text = re.sub(r"\s+", " ", content).strip()
-
-            if not plain_text:
-                raise ValueError("Empty text file.")
-
-            chunks = smart_chunk_text(plain_text, chunk_size, overlap)
-            combined_chunks.extend(chunks)
+            with open(file_name, "r", encoding="utf-8") as f:
+                text = f.read()
+                knowledge += "\n" + text
         except Exception as e:
-            print(f"❌ Error processing {file}: {e}")
+            print(f"Error reading {file_name}: {e}")
+    return knowledge.strip()
 
-    return combined_chunks
+# Simple text chunking
+def chunk_text(text, max_chunk_length=500):
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    chunks = []
+    current_chunk = ""
 
-# Embedding + Indexing
-def embed_texts(text_list):
-    if not text_list:
-        raise ValueError("⚠️ No texts to embed.")
-    encoded = tokenizer(text_list, padding=True, truncation=True, return_tensors="pt")
-    with torch.no_grad():
-        output = model(**encoded)
-    return output.last_hidden_state.mean(dim=1).numpy()
+    for sentence in sentences:
+        if len(current_chunk) + len(sentence) <= max_chunk_length:
+            current_chunk += " " + sentence
+        else:
+            chunks.append(current_chunk.strip())
+            current_chunk = sentence
+    if current_chunk:
+        chunks.append(current_chunk.strip())
 
-# Load and embed text
-chunks = process_text_files(FILES)
-if not chunks:
-    raise ValueError("⚠️ No text chunks found.")
+    return chunks
 
-tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-mpnet-base-v2")
-model = AutoModel.from_pretrained("sentence-transformers/all-mpnet-base-v2")
-chunk_embeddings = embed_texts(chunks)
+# Load the txt files
+FILES = [f"Main{i}.txt" for i in range(1, 3)]  # Example: Main1.txt, Main2.txt
+knowledge_base = load_text_files(FILES)
+chunks = chunk_text(knowledge_base)
+
+# Helper: Build prompt with context
+def build_prompt(user_message):
+    context = "\n".join(chunks[:10])  # Take first 10 chunks as context for simplicity
+    prompt = f""" You are an AI-supported financial expert. You answer questions **exclusively in the context of the "Financial Markets" lecture** at the University of Duisburg-Essen. Your answers are **clear, fact-based, and clearly formulated.**
+Observe the following rules:
+1. Use the provided lecture excerpts ("lecture_slides") primarily as a source of information.
+2. If an answer is **not** covered by the lecture content, you can add to it – but only if you are **absolutely certain**. No hallucinations!
+3. If you are unsure, answer politely:
+_"Sorry. Unfortunately, I don't know the answer to this question."_
+4. If a formula is relevant, **show the exact formula** and explain it in **simple terms.**
+5. Avoid vague statements. It's better not to give an answer at all than to give an uncertain one. 
+6. Only answer in german!
+
+Knowledge Base:
+{context}
 
-nn_model = NearestNeighbors(n_neighbors=3, metric="cosine")
-nn_model.fit(chunk_embeddings)
+User Question: {user_message}
+Answer:"""
+    return prompt
 
 # Chat function
 def respond(message, history):
-    try:
-        query_embedding = embed_texts([message])
-        distances, indices = nn_model.kneighbors(query_embedding)
-
-        CONFIDENCE_THRESHOLD = 0.6
-        if distances[0][0] > CONFIDENCE_THRESHOLD:
-            return f"Entschuldigung. Ich kenne die Antwort auf diese Frage leider nicht. (Nächste Distanzen: {distances[0]})"
-
-        relevant_chunks = [chunks[i] for i in indices[0]]
-        conversation = "\n".join(
-            [f"User: {m['content']}" if m["role"] == "user" else f"AI: {m['content']}" for m in history[-5:]]
-        )
-        context = "\n".join(relevant_chunks)
-
-        prompt = f"""
-### SYSTEM
-Du bist ein KI-gestützter Finanzexperte. Du beantwortest Fragen **ausschließlich im Kontext der Vorlesung "Finanzmärkte"** an der Universität Duisburg-Essen. Deine Antworten sind **klar, faktenbasiert und verständlich formuliert.**
-Beachte folgende Regeln:
-1. Nutze primär die bereitgestellten Vorlesungsausschnitte („lecture_slides“) als Informationsquelle.
-2. Falls eine Antwort **nicht** durch die Vorlesungsinhalte gedeckt ist, kannst du sie ergänzen – aber nur, wenn du **absolut sicher** bist. Keine Halluzinationen!
-3. Wenn du dir nicht sicher bist, antworte höflich:  
-   _"Entschuldigung. Ich kenne die Antwort auf diese Frage leider nicht."_
-4. Wenn eine Formel relevant ist, **zeige die genaue Formel**, und erkläre diese in **einfachen Worten.**
-5. Vermeide vage Aussagen. Nenne lieber keine Antwort als eine unsichere.
----
-### VORLESUNGSAUSSCHNITTE
-{context}
----
-### GESPRÄCHSVERLAUF
-{conversation}
----
-### NUTZER
-{message}
----
-### ASSISTENT
-"""
-
-        payload = {
-            "inputs": prompt,
-            "parameters": {"max_new_tokens": 400, "temperature": 0.3},
-        }
+    prompt = build_prompt(message)
+
+    payload = {
+        "inputs": prompt,
+        "parameters": {"temperature": 0.3, "max_new_tokens": 300},
+    }
 
+    try:
         response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=30)
         response.raise_for_status()
         output = response.json()
-        reply = output[0]["generated_text"].strip()
-        reply = reply.split("--- ASSISTENT")[-1].strip()
-
+        generated_text = output[0]["generated_text"]
+        # Remove the prompt part from the response if necessary
+        answer = generated_text.split("Answer:")[-1].strip()
     except Exception as e:
-        print("❌ API Error:", e)
-        reply = "Ein Fehler ist aufgetreten. Bitte versuche es später erneut."
-
-    return reply
-
-# Launch the Gradio UI
-gr.ChatInterface(respond, title="Finanzmärkte RAG Chatbot", chatbot=gr.Chatbot(type="messages")).launch()
+        print("API Error:", e)
+        answer = "❌ Error contacting the model. Please try again later."
+
+    history.append((message, answer))
+    return history
+
+# Create Gradio Interface
+chatbot = gr.Chatbot()
+demo = gr.ChatInterface(
+    fn=respond,
+    chatbot=chatbot,
+    title="📚 Text Knowledge Chatbot",
+    description="Ask questions based on the given text files.",
+)
+
+demo.launch()