Update app.py

app.py

@@ -1,64 +1,113 @@
+import re
+import requests
+from bs4 import BeautifulSoup
+from duckduckgo_search import ddg
+from googlesearch import search as google_search
+# For Bing we use SerpAPI (requires SERPAPI_API_KEY env var)
+from serpapi import GoogleSearch as SerpBing
+from rake_nltk import Rake
 import gradio as gr
-from huggingface_hub import InferenceClient
+from transformers import pipeline
 
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+# 1) Keyword extractor
+rake = Rake()
+def extract_keywords(text):
+    rake.extract_keywords_from_text(text)
+    return [kw for kw, score in rake.get_ranked_phrases_with_scores()[:5]]
 
+# 2) Search functions
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
+def bing_search(query, api_key, num=5):
+    params = {"engine": "bing", "q": query, "api_key": api_key}
+    client = SerpBing(params)
+    results = client.get_dict().get('organic_results', [])
+    return [r['link'] for r in results if not r.get('sponsored')][:num]
 
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+def google_search_links(query, num=5):
+    return list(google_search(query, num_results=num))
 
-    messages.append({"role": "user", "content": message})
+def ddg_search_links(query, num=5):
+    return [r['href'] for r in ddg(query, max_results=num)]
 
-    response = ""
+# 3) Fetch page text
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
+def fetch_text(url):
+    try:
+        resp = requests.get(url, timeout=3)
+        soup = BeautifulSoup(resp.text, 'html.parser')
+        texts = soup.find_all(['p', 'h1', 'h2', 'h3'])
+        return ' '.join([t.get_text() for t in texts])
+    except:
+        return ''
 
-        response += token
-        yield response
+# 4) Model loader
+generator = pipeline('text-generation', model='google/flan-t5-small', trust_remote_code=True)
 
+def model_answer(prompt):
+    return generator(prompt, max_length=256, do_sample=False)[0]['generated_text']
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+# 5) Check for forbidden search
+VERBOT = [
+    "bitte nicht im internet suchen", "keine websuche", "mach das ohne web",
+    "ohne online", "nur dein wissen", "nicht googeln", "such nicht"
+]
+def search_forbidden(prompt):
+    pl = prompt.lower()
+    return any(v in pl for v in VERBOT)
 
+# 6) Check uncertainty
+UNCERT = ["ich weiß nicht", "nicht in meinen daten", "keine information", "ich bin mir nicht sicher"]
+def is_uncertain(answer):
+    al = answer.lower()
+    return any(u in al for u in UNCERT)
 
-if __name__ == "__main__":
-    demo.launch()
+# 7) Combined logic
+def process(prompt, web_enabled, serpapi_key):
+    # Extract keywords
+    keys = extract_keywords(prompt)
+    # Base answer
+    if search_forbidden(prompt):
+        ans = model_answer(prompt)
+        if is_uncertain(ans):
+            return (
+                "Ich weiß leider nichts über das Thema aus meinem Training. "
+                "Da du Websuche verboten hast, versuche ich es trotzdem, "
+                "aber es kann ungenau sein.\n\n" + ans
+            )
+        return ans
+    if not web_enabled:
+        return model_answer(prompt)
+    # Web enabled, try model first
+    ans = model_answer(prompt)
+    if not is_uncertain(ans):
+        return ans
+    # Uncertain: perform multi-search
+    # Google
+    g = google_search_links(' '.join(keys))
+    # DuckDuckGo
+    d = ddg_search_links(' '.join(keys))
+    # Bing
+    b = bing_search(' '.join(keys), serpapi_key)
+    urls = list(dict.fromkeys(g + d + b))
+    # Fetch and combine texts
+    texts = [fetch_text(u) for u in urls[:3]]
+    combined = '\n'.join(texts)
+    # Summarize
+    summary = generator(combined, max_length=256)[0]['generated_text']
+    return summary
+
+# 8) Gradio UI
+def main(prompt, web_enabled, serpapi_key):
+    return process(prompt, web_enabled, serpapi_key)
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Intelligente KI mit Multi-Engine-Websuche")
+    with gr.Row():
+        prompt = gr.Textbox(label="Dein Prompt", lines=3)
+        web = gr.Checkbox(label="Websuche aktivieren", value=False)
+    serp = gr.Textbox(label="SerpAPI Key (für Bing)", placeholder="Optional für Bing-Suche")
+    btn = gr.Button("Antwort generieren")
+    output = gr.Textbox(label="Antwort", lines=10)
+    btn.click(main, inputs=[prompt, web, serp], outputs=output)
+
+demo.launch()