Dodanie aplikacji Szuflada

app.py

@@ -1,265 +1,62 @@
-# Wersja zmodyfikowana przez ChatGPT. 
-# Tworzenie przy starcie aplikacji bazy tylko wtedy, gdy jej nie ma.
-import os
 import sys
 import uuid
-import time
-from typing import List, Dict, Any, Optional, Tuple
 
 import gradio as gr
 
-# Zakładane API w database_setup:
-# - load_existing_database(persist_dir: str) -> obiekt bazy/collection lub None
-# - update_database(persist_dir: str, progress_cb: callable | None = None) -> obiekt bazy/collection (po aktualizacji)
-# - initialize_database(persist_dir: str = "data/chroma",
-#                       batch_size: int = 64,
-#                       persist_every: int = 200,
-#                       progress_cb: callable | None = None) -> obiekt bazy/collection
-from database_setup import initialize_database  # wymagane
-try:
-    from database_setup import load_existing_database  # opcjonalne, ale zalecane
-except Exception:
-    load_existing_database = None  # type: ignore
-try:
-    from database_setup import update_database  # opcjonalne, ale zalecane
-except Exception:
-    update_database = None  # type: ignore
-
+from database_setup import initialize_database
 from chat_utils import create_rag_chain, format_sources, create_session_history_manager
 from langchain_core.runnables.history import RunnableWithMessageHistory
 
-# Konfiguracja persist i automatycznej aktualizacji
-PERSIST_DIR = os.getenv("CHROMA_DIR", "data/chroma")
-AUTO_REFRESH_DB = os.getenv("AUTO_REFRESH_DB", "true").lower() == "true"
-
-# Globalne uchwyty
-baza = None
-rag_chain = None
-conversational_rag_chain: Optional[RunnableWithMessageHistory] = None
-
-def log(msg: str) -> None:
-    print(msg, flush=True)
-
-def human_size(num_bytes: int) -> str:
-    units = ["B","KB","MB","GB","TB"]
-    size = float(num_bytes)
-    for u in units:
-        if size < 1024:
-            return f"{size:.1f} {u}"
-        size /= 1024
-    return f"{size:.1f} PB"
-
-def db_disk_stats(persist_dir: str) -> Tuple[int,int]:
-    """Zwraca (liczba_plików, suma_rozmiarów_bajtów) dla katalogu bazy."""
-    if not os.path.isdir(persist_dir):
-        return 0, 0
-    total = 0
-    files = 0
-    for root, _, filenames in os.walk(persist_dir):
-        for fn in filenames:
-            files += 1
-            fp = os.path.join(root, fn)
-            try:
-                total += os.path.getsize(fp)
-            except Exception:
-                pass
-    return files, total
-
-def is_database_empty(db) -> bool:
-    """True jeśli baza nie istnieje lub nie zawiera żadnych rekordów."""
-    try:
-        if db is None:
-            return True
-        if hasattr(db, "count"):
-            return db.count() == 0
-        if hasattr(db, "get"):
-            res = db.get(limit=1)
-            if isinstance(res, dict):
-                ids = res.get("ids") or []
-                return len(ids) == 0
-        return False
-    except Exception:
-        return True
-
-def attach_rag_chain(db) -> None:
-    """Tworzy/aktualizuje globalny łańcuch RAG po zmianie bazy."""
-    global baza, rag_chain, conversational_rag_chain
-    baza = db
-    get_session_history = create_session_history_manager()
-    rag_chain = create_rag_chain(baza)
-    conversational_rag_chain = RunnableWithMessageHistory(
-        rag_chain,
-        get_session_history,
-        input_messages_key="input",
-        history_messages_key="chat_history",
-        output_messages_key="answer",
-    )
-    log("RAG chain gotowy.")
-
-def load_db_if_exists() -> Optional[Any]:
-    """Wczytuje istniejącą bazę, jeśli jest funkcja load_existing_database, inaczej None."""
-    if load_existing_database is None:
-        log("Brak load_existing_database – pomijam wczytywanie.")
-        return None
+print("Inicjalizacja bazy danych...")
+baza = initialize_database()
+if baza is None:
+    print("Nie udało się zainicjalizować bazy danych. Zakończenie pracy.")
+    sys.exit(1)
+
+rag_chain = create_rag_chain(baza)
+get_session_history = create_session_history_manager()
+conversational_rag_chain = RunnableWithMessageHistory(
+    rag_chain,
+    get_session_history,
+    input_messages_key="input",
+    history_messages_key="chat_history",
+    output_messages_key="answer",
+)
+
+def respond(message, chat_history, sess_id):
+    """Obsługuje odpowiedź na wiadomość użytkownika."""
     try:
-        log(f"Próba wczytania bazy z: {PERSIST_DIR}")
-        db = load_existing_database(PERSIST_DIR)  # type: ignore
-        if db:
-            log("Baza została wczytana.")
-        return db
-    except Exception as e:
-        log(f"Nie udało się wczytać bazy: {e}")
-        return None
-
-# ---------- Funkcje do UI: status oraz inicjalizacja/aktualizacja ----------
-
-def get_db_status() -> str:
-    """Zwraca opis stanu bazy do wyświetlenia w UI."""
-    db = load_db_if_exists()
-    empty = is_database_empty(db)
-    file_count, total_bytes = db_disk_stats(PERSIST_DIR)
-    size_txt = human_size(total_bytes)
-    lines = []
-    lines.append(f"Katalog persist: {PERSIST_DIR}")
-    lines.append(f"Plików w katalogu: {file_count}, łączny rozmiar: {size_txt}")
-    if db is None:
-        lines.append("Stan bazy: brak lub nie udało się wczytać.")
-    else:
-        lines.append("Stan bazy: wczytana.")
-        lines.append(f"Czy pusta: {'tak' if empty else 'nie'}")
-        if not empty and hasattr(db, 'count'):
-            try:
-                lines.append(f"Liczba rekordów: {db.count()}")
-            except Exception:
-                pass
-    # Jeżeli baza jest wczytana i niepusta, zadbaj, by łańcuch był aktywny
-    if db and not empty:
-        attach_rag_chain(db)
-    return "\n".join(lines)
-
-def init_or_update_database(progress=gr.Progress(track_tqdm=False)) -> str:
-    """
-    Ręczna inicjalizacja lub aktualizacja bazy z przycisku.
-    Wyświetla krok po kroku, bez blokowania czatu.
-    """
-    progress(0, desc="Start procesu")
-    db = load_db_if_exists()
-    if db is None or is_database_empty(db):
-        progress(0.05, desc="Budowanie bazy od zera")
-        try:
-            # initialize_database może przyjąć progress_cb, ale nie wymagamy tego
-            db = initialize_database(persist_dir=PERSIST_DIR)  # type: ignore
-            progress(0.75, desc="Zapis i przygotowanie RAG")
-            attach_rag_chain(db)
-            progress(1.0, desc="Zakończono: baza zbudowana")
-            return "Baza zbudowana i gotowa."
-        except TypeError:
-            db = initialize_database()  # type: ignore
-            attach_rag_chain(db)
-            progress(1.0, desc="Zakończono: baza zbudowana (bez persist_dir)")
-            return "Baza zbudowana i gotowa (initialize_database bez persist_dir)."
-        except Exception as e:
-            progress(1.0, desc="Błąd budowy")
-            return f"Błąd podczas budowania bazy: {e}"
-    else:
-        if AUTO_REFRESH_DB:
-            progress(0.1, desc="Aktualizacja istniejącej bazy")
-            try:
-                if update_database:
-                    db = update_database(PERSIST_DIR)  # type: ignore
-                    progress(0.8, desc="Aktualizacja zakończona, odświeżam RAG")
-                    attach_rag_chain(db)
-                    progress(1.0, desc="Gotowe")
-                    return "Baza zaktualizowana i gotowa."
-                else:
-                    # fallback – spróbuj initialize_database jako „update”, jeśli wspiera
-                    try:
-                        db = initialize_database(persist_dir=PERSIST_DIR, mode="update")  # type: ignore
-                        attach_rag_chain(db)
-                        progress(1.0, desc="Gotowe")
-                        return "Baza zaktualizowana przez initialize_database(mode='update')."
-                    except TypeError:
-                        progress(1.0, desc="Pominięto")
-                        return "Brak update_database i brak wsparcia mode='update' – pomijam aktualizację."
-            except Exception as e:
-                progress(1.0, desc="Błąd aktualizacji")
-                return f"Błąd podczas aktualizacji bazy: {e}"
-        else:
-            progress(1.0, desc="Pominięto")
-            return "AUTO_REFRESH_DB=false – aktualizacja pominięta. Baza została tylko wczytana."
-
-# ---------- Obsługa czatu ----------
-
-def respond(user_input: str, messages: List[Dict[str, Any]] | None, sess_id: str | None):
-    """
-    Obsługuje odpowiedź czatu.
-    Jeśli baza niegotowa/pusta – nie wisi, tylko prosi o inicjalizację z panelu.
-    """
-    if messages is None:
-        messages = []
-    messages.append({"role": "user", "content": user_input})
-
-    sid = sess_id if isinstance(sess_id, str) and sess_id else str(uuid.uuid4())
-
-    # Jeżeli łańcuch nie jest gotowy, spróbuj wczytać bazę i tylko podpiąć RAG – bez budowy.
-    global conversational_rag_chain
-    if conversational_rag_chain is None:
-        db = load_db_if_exists()
-        if db and not is_database_empty(db):
-            attach_rag_chain(db)
-        else:
-            messages.append({
-                "role": "assistant",
-                "content": (
-                    "Baza nie jest jeszcze gotowa. Wejdź w sekcję „Zarządzanie bazą” i wybierz: "
-                    "Zainicjalizuj lub zaktualizuj bazę. "
-                    "Po zakończeniu wróć do czatu i zadaj pytanie ponownie."
-                )
-            })
-            return messages
-
-    # W tym miejscu zakładamy, że RAG jest już gotowy
-    try:
-        assert conversational_rag_chain is not None
-        start_t = time.time()
-        result = conversational_rag_chain.invoke(
-            {"input": user_input},
-            config={"configurable": {"session_id": sid}},
+        response = conversational_rag_chain.invoke(
+            {"input": message},
+            config={"configurable": {"session_id": sess_id}},
         )
-        elapsed = time.time() - start_t
-        log(f"RAG inference: {elapsed:.2f}s")
     except Exception as e:
-        messages.append({"role": "assistant", "content": f"Błąd podczas przetwarzania: {e}"})
-        return messages
+        chat_history.append((message, f"Błąd podczas przetwarzania: {e}"))
+        return chat_history
 
-    context_docs = result.get("context", [])
+    context_docs = response.get("context", [])
+    # Debug: wypisz poziom podobieństwa
     try:
-        # Opcjonalny debug podobieństw (jeśli dostępne)
-        if baza and hasattr(baza, "similarity_search_with_score"):
-            debug_scores = baza.similarity_search_with_score(user_input, k=len(context_docs) or 4)  # type: ignore[attr-defined]
-            for i, (doc, score) in enumerate(debug_scores):
-                print(f"Chunk {i+1}: similarity_score={score}, title={doc.metadata.get('title')}", flush=True)
+        debug_scores = baza.similarity_search_with_score(message, k=len(context_docs))
+        for i, (doc, score) in enumerate(debug_scores):
+            print(f"Chunk {i+1}: similarity_score={score}, title={doc.metadata.get('title')}")
     except Exception:
         pass
 
     sources_md = format_sources(context_docs)
-    answer = result.get("answer") or ""
-    answer_with_sources = f"{answer}\n\nŹródła:\n{sources_md}"
-
-    messages.append({"role": "assistant", "content": answer_with_sources})
-    return messages
-
-# ---------- UI ----------
+    answer = response.get("answer") or ""
+    answer_with_sources = f"{answer}\n\n**Źródła:**\n{sources_md}"
+    chat_history.append((message, answer_with_sources))
+    return chat_history
 
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Szuflada Chatbot") as demo:
-    session_id = gr.State(str(uuid.uuid4()))
+    session_id = gr.State(lambda: str(uuid.uuid4()))
 
     gr.Markdown(
         "# Czat z Moją Szufladą\n"
-        "### Zadaj pytanie na temat treści ze strony mojaszuflada.pl"
+        "### Zadaj pytanie na temat treści ze strony [mojaszuflada.pl](https://mojaszuflada.pl)"
     )
-
-    chatbot = gr.Chatbot(label="Rozmowa", height=500, type="messages")
+    chatbot = gr.Chatbot(label="Rozmowa", height=500)
 
     with gr.Row():
         msg = gr.Textbox(
@@ -275,18 +72,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Szuflada Chatbot
     msg.submit(respond, [msg, chatbot, session_id], [chatbot]) \
        .then(lambda: gr.update(value=""), None, [msg], queue=False)
 
-    with gr.Accordion("Zarządzanie bazą", open=False):
-        status_btn = gr.Button("Sprawdź status bazy")
-        init_btn = gr.Button("Zainicjalizuj lub zaktualizuj bazę", variant="primary")
-        status_out = gr.Textbox(label="Status", lines=8)
-        init_out = gr.Textbox(label="Wynik inicjalizacji/aktualizacji", lines=6)
-
-        status_btn.click(fn=get_db_status, inputs=None, outputs=status_out)
-        init_btn.click(fn=init_or_update_database, inputs=None, outputs=init_out) \
-                .then(fn=get_db_status, inputs=None, outputs=status_out)
-
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.getenv("PORT", 7860))
-    )
+  #  demo.launch(inbrowser=True)
+    demo.launch(server_name="127.0.0.1", inbrowser=False, share=False) # Zmiana PW