Dodanie aplikacji Szuflada

README.md

@@ -1 +1,96 @@
-Szuflada – świeży start (2025-09-06T18:56:22+02:00)
+---
+title: Szuflada
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.1 # PW zmieniłem wersję Radio
+app_file: app.py
+pinned: false
+license: cc-by-4.0
+short_description: Chatbot korzystający z zasobów serwisu mojaszuflada.pl
+---
+  
+# Szuflada
+
+Czatbot korzystający z zasobów serwisu [mojaszuflada.pl](https://mojaszuflada.pl), wykorzystujący Gradio oraz RAG z lokalną bazą Chroma i Hugging Face Inference API.
+
+## Instalacja
+
+1. Sklonuj repozytorium:
+
+   ```bash
+   git clone https://github.com/<użytkownik>/szuflada.git
+   cd szuflada
+   ```
+
+2. Utwórz i aktywuj środowisko wirtualne:
+
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate   # Linux/macOS
+   venv\Scripts\activate    # Windows
+   ```
+
+3. Zainstaluj zależności:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. Zaloguj się do Hugging Face (jeśli korzystasz z API):
+
+   ```bash
+   huggingface-cli login
+   ```
+
+5. (Opcjonalnie) Ustaw zmienną środowiskową z tokenem:
+
+   ```bash
+   export HUGGINGFACEHUB_API_TOKEN=Twój_Token
+   ```
+
+## Użycie
+
+Uruchom aplikację lokalnie:
+
+```bash
+python app.py
+```
+
+Aplikacja będzie dostępna pod adresem <http://localhost:7860>. Otwórz tę stronę w przeglądarce, aby rozpocząć czat.
+
+## Osadzanie na innych stronach internetowych
+
+### Metoda 1: iframe
+
+```html
+<iframe src="http://adres_twojej_aplikacji:7860" width="700" height="800" frameborder="0"></iframe>
+```
+
+### Metoda 2: Embed Gradio (Hugging Face Spaces)
+
+Jeśli aplikacja jest wdrożona jako Space na Hugging Face, użyj oficjalnego skryptu:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@gradio/embed"></script>
+<gradio-embed
+  src="username/szuflada"  <!-- zastąp username swoją nazwą użytkownika/Space -->
+  width="700"
+  height="800"
+></gradio-embed>
+```
+
+### Metoda 3: JavaScript SDK
+
+```html
+<script type="module">
+  import Gradio from "https://cdn.jsdelivr.net/npm/@gradio/embed@2.0.0/+esm";
+  new Gradio.Embed("https://huggingface.co/embed/username/szuflada", {
+    container: document.getElementById("gradio-container"),
+    width: 700,
+    height: 800
+  });
+</script>
+<div id="gradio-container"></div>
+```

app.py

@@ -0,0 +1,105 @@
+# Wersja zmodyfikowana przez ChatGPT
+import os
+import sys
+import uuid
+from typing import List, Dict, Any
+
+import gradio as gr
+
+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
+
+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(user_input: str, messages: List[Dict[str, Any]] | None, sess_id: str | None):
+    """
+    Obsługuje odpowiedź na wiadomość użytkownika.
+    Wejście/wyjście to lista słowników w formacie:
+      {"role": "user" | "assistant", "content": "tekst"}
+    """
+    # Upewnij się, że mamy listę wiadomości
+    if messages is None:
+        messages = []
+
+    # Dopisz wiadomość użytkownika do UI
+    messages.append({"role": "user", "content": user_input})
+
+    # Zapewnij tekstowe session_id (State nie powinien trzymać funkcji)
+    sid = sess_id if isinstance(sess_id, str) and sess_id else str(uuid.uuid4())
+
+    try:
+        result = conversational_rag_chain.invoke(
+            {"input": user_input},
+            config={"configurable": {"session_id": sid}},
+        )
+    except Exception as e:
+        messages.append({"role": "assistant", "content": f"Błąd podczas przetwarzania: {e}"})
+        return messages
+
+    context_docs = result.get("context", [])
+    # Debug podobieństw (bez przerywania działania)
+    try:
+        debug_scores = baza.similarity_search_with_score(user_input, k=len(context_docs) or 4)
+        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
+
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Szuflada Chatbot") as demo:
+    # State musi przechowywać wartość, nie funkcję
+    session_id = gr.State(str(uuid.uuid4()))
+
+    gr.Markdown(
+        "# Czat z Moją Szufladą\n"
+        "### Zadaj pytanie na temat treści ze strony mojaszuflada.pl"
+    )
+
+    # Nowy format wiadomości
+    chatbot = gr.Chatbot(label="Rozmowa", height=500, type="messages")
+
+    with gr.Row():
+        msg = gr.Textbox(
+            show_label=False,
+            placeholder="Wpisz swoje pytanie...",
+            container=False,
+            scale=7,
+        )
+        submit_btn = gr.Button("Wyślij", variant="primary", scale=1)
+
+    # Kolejność argumentów musi odpowiadać sygnaturze respond:
+    # (user_input, messages, sess_id)
+    submit_btn.click(respond, [msg, chatbot, session_id], [chatbot]) \
+              .then(lambda: gr.update(value=""), None, [msg], queue=False)
+    msg.submit(respond, [msg, chatbot, session_id], [chatbot]) \
+       .then(lambda: gr.update(value=""), None, [msg], queue=False)
+
+if __name__ == "__main__":
+    # Na HF Spaces wiąż na wszystkie interfejsy i użyj portu z ENV
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", 7860)),
+        ssr_mode=False
+    )

chat_utils.py

@@ -0,0 +1,87 @@
+from langchain_chroma import Chroma
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain.chains import create_history_aware_retriever, create_retrieval_chain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_community.chat_message_histories import ChatMessageHistory
+from langchain_core.runnables.history import RunnableWithMessageHistory
+
+def create_rag_chain(database: Chroma):
+    """
+    Tworzy łańcuch RAG z obsługą historii konwersacji.
+    """
+    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.0)
+    retriever = database.as_retriever(search_kwargs={"k": 3})
+
+    # Prompt do kontekstualizacji pytania
+    contextualize_q_system_prompt = (
+        "Biorąc pod uwagę historię czatu i ostatnie pytanie użytkownika, "
+        "które może odnosić się do kontekstu w historii czatu, "
+        "sformułuj samodzielne pytanie, które można zrozumieć bez historii czatu. "
+        "NIE odpowiadaj na pytanie, po prostu przeformułuj je, jeśli to konieczne, "
+        "a w przeciwnym razie zwróć je w niezmienionej formie."
+    )
+    contextualize_q_prompt = ChatPromptTemplate.from_messages([
+        ("system", contextualize_q_system_prompt),
+        MessagesPlaceholder("chat_history"),
+        ("human", "{input}"),
+    ])
+
+    history_aware_retriever = create_history_aware_retriever(
+        llm, retriever, contextualize_q_prompt
+    )
+
+    # Prompt do generowania odpowiedzi
+    qa_system_prompt = (
+        "Jesteś asystentem do zadawania pytań i odpowiedzi na temat treści ze strony mojaszuflada.pl. "
+        "Użyj poniższych fragmentów odzyskanego kontekstu, aby odpowiedzieć na pytanie. "
+        "Odpowiadaj zawsze w języku polskim. "
+        "Jeśli nie znasz odpowiedzi, po prostu powiedz, że tego nie wiesz. "
+        "Zachowaj zwięzłość odpowiedzi, ale bądź pomocny i przyjazny."
+        "\n\n{context}"
+    )
+    qa_prompt = ChatPromptTemplate.from_messages([
+        ("system", qa_system_prompt),
+        MessagesPlaceholder("chat_history"),
+        ("human", "{input}"),
+    ])
+
+    question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)
+    rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)
+
+    return rag_chain
+
+def format_sources(source_docs):
+    """
+    Formatuje listę źródeł do wyświetlenia w odpowiedzi.
+    """
+    if not source_docs:
+        return "?"
+    
+    sources = []
+    for doc in source_docs:
+        metadata = doc.metadata
+        title = metadata.get("title", "Brak tytułu")
+        source_url = metadata.get("source", "Brak URL")
+        
+        pub_date_raw = metadata.get("published_time")
+        if pub_date_raw:
+            pub_date = pub_date_raw.split("T")[0]
+            sources.append(f"- [{title}]({source_url}) ({pub_date})")
+        else:
+            sources.append(f"- [{title}]({source_url})")
+    return "\n".join(sources)
+
+def create_session_history_manager():
+    """
+    Tworzy menedżer historii sesji.
+    """
+    store = {}
+    
+    def get_session_history(session_id: str) -> BaseChatMessageHistory:
+        if session_id not in store:
+            store[session_id] = ChatMessageHistory()
+        return store[session_id]
+    
+    return get_session_history

database_setup.py

@@ -0,0 +1,159 @@
+from bs4 import BeautifulSoup
+import re
+from langchain_chroma import Chroma
+from langchain_openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+import requests
+from tqdm import tqdm
+
+def process_documents(docs: list[Document]) -> list[Document]:
+    """
+    Przetwarza listę dokumentów, wyodrębniając treść i metadane z HTML.
+    """
+    processed_docs = []
+    for doc in docs:
+        soup = BeautifulSoup(doc.page_content, "lxml")
+
+        # Wyodrębnienie głównej treści
+        article = soup.find("article")
+        if article:
+            content = article.get_text(separator="\n", strip=True)
+        else:
+            content = soup.get_text(separator="\n", strip=True)
+
+        # Wyodrębnienie metadanych
+        metadata = doc.metadata.copy()
+        
+        # Title ze znacznika <title>
+        if soup.title:
+            title_text = soup.title.get_text(strip=True)
+            if title_text:
+                metadata["title"] = title_text
+
+        # Data publikacji
+        pub_date_tag = soup.find("meta", property="article:published_time")
+        if pub_date_tag and pub_date_tag.get("content"):
+            metadata["published_time"] = pub_date_tag["content"]
+        else:
+            time_tag = soup.find("time")
+            if time_tag and time_tag.get("datetime"):
+                metadata["published_time"] = time_tag.get("datetime")
+            elif time_tag and time_tag.get_text(strip=True):
+                metadata["published_time"] = time_tag.get_text(strip=True)
+            else:
+                text = soup.get_text(separator="\n", strip=True)
+                m = re.search(r"Opublikowano(?: w dniu)?[:\s]+([0-9]{1,2}\s+\w+\s+\d{4})", text, re.IGNORECASE)
+                if m:
+                    metadata["published_time"] = m.group(1)
+
+        # Kategorie
+        categories = [
+            tag["content"]
+            for tag in soup.find_all("meta", property="article:section")
+            if tag.get("content")
+        ]
+        if categories:
+            metadata["categories"] = ", ".join(categories)
+
+        # Słowa kluczowe
+        keywords = [
+            tag["content"]
+            for tag in soup.find_all("meta", property="article:tag")
+            if tag.get("content")
+        ]
+        if keywords:
+            metadata["keywords"] = ", ".join(keywords)
+
+        processed_docs.append(Document(page_content=content, metadata=metadata))
+    return processed_docs
+
+def initialize_database(persist_directory="./szuflada", clear_existing=True):
+    """
+    Inicjalizuje bazę danych Chroma z danymi ze strony mojaszuflada.pl
+    """
+    embedder = OpenAIEmbeddings(model="text-embedding-3-small", show_progress_bar=True)
+    baza = Chroma(collection_name="szuflada", embedding_function=embedder, persist_directory=persist_directory)
+
+    if clear_existing:
+        print("Czyszczenie istniejącej kolekcji w bazie danych...")
+        try:
+            baza.delete_collection()
+            print("Kolekcja została wyczyszczona.")
+            baza = Chroma(collection_name="szuflada", embedding_function=embedder, persist_directory=persist_directory)
+        except Exception as e:
+            print(f"Nie można było wyczyścić kolekcji (może nie istniała): {e}")
+
+    print("Pobieranie i parsowanie mapy strony...")
+    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
+    sitemap_url = "https://mojaszuflada.pl/wp-sitemap.xml"
+    docs = []
+
+    try:
+        response = requests.get(sitemap_url, headers=headers)
+        response.raise_for_status()
+        sitemap_xml = response.text
+
+        sitemap_soup = BeautifulSoup(sitemap_xml, "xml")
+        urls = [loc.text for loc in sitemap_soup.find_all("loc")]
+
+        sitemap_urls = [url for url in urls if url.endswith(".xml")]
+        page_urls = [url for url in urls if not url.endswith(".xml")]
+
+        for sub_sitemap_url in tqdm(sitemap_urls, desc="Parsowanie pod-map"):
+            try:
+                response = requests.get(sub_sitemap_url, headers=headers)
+                response.raise_for_status()
+                sub_sitemap_xml = response.text
+                sub_sitemap_soup = BeautifulSoup(sub_sitemap_xml, "xml")
+                page_urls.extend([loc.text for loc in sub_sitemap_soup.find_all("loc")])
+            except requests.RequestException as e:
+                print(f"Pominięto pod-mapę {sub_sitemap_url}: {e}")
+
+        print(f"Znaleziono {len(page_urls)} adresów URL do przetworzenia.")
+
+        for url in tqdm(page_urls, desc="Pobieranie stron"):
+            try:
+                response = requests.get(url, headers=headers)
+                response.raise_for_status()
+                doc = Document(
+                    page_content=response.text,
+                    metadata={"source": url, "loc": url}
+                )
+                docs.append(doc)
+            except requests.RequestException as e:
+                print(f"Pominięto stronę {url}: {e}")
+
+    except requests.RequestException as e:
+        print(f"Krytyczny błąd: Nie udało się pobrać głównej mapy strony: {e}")
+
+    if not docs:
+        print("Nie załadowano żadnych dokumentów.")
+        return None
+
+    processed_docs = process_documents(docs)
+    print(f"\nPrzetworzono {len(processed_docs)} dokumentów.")
+
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    chunks = text_splitter.split_documents(processed_docs)
+
+    # Walidacja metadanych
+    required_meta_keys = ["source", "title", "published_time"]
+    missing_counts = {k: 0 for k in required_meta_keys}
+    for chunk in chunks:
+        md = chunk.metadata or {}
+        for k in required_meta_keys:
+            if not md.get(k):
+                missing_counts[k] += 1
+
+    print(f"Liczba chunków: {len(chunks)}")
+    print("Braki metadanych:", missing_counts)
+
+    # Dodawanie chunków do bazy
+    batch_size = 1000
+    for i in range(0, len(chunks), batch_size):
+        baza.add_documents(documents=chunks[i:i + batch_size])
+
+    print("Baza danych została zainicjalizowana pomyślnie.")
+    return baza
+    return baza

requirements.txt

@@ -0,0 +1,11 @@
+beautifulsoup4==4.13.4
+langchain==0.3.27
+langchain_chroma==0.2.5
+langchain_community==0.3.27
+langchain_core==0.3.74
+langchain_openai==0.3.30
+gradio==4.44.1 # WP dodane dwa wiersze dot. Gradio
+gradio_client==1.3.0
+Requests==2.32.4
+tqdm==4.66.4
+lxml

scrap.py

@@ -0,0 +1,177 @@
+# Ten plik jest odpowiedzialny za scrapowanie danych ze strony.
+from langchain_community.document_loaders import SitemapLoader
+from bs4 import BeautifulSoup
+import re
+from langchain_chroma import Chroma
+from langchain_openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+import requests
+from tqdm import tqdm
+
+def process_documents(docs: list[Document]) -> list[Document]:
+    """
+    Przetwarza listę dokumentów, wyodrębniając treść i metadane z HTML.
+    """
+    processed_docs = []
+    for doc in docs:
+        soup = BeautifulSoup(doc.page_content, "lxml")
+
+        # Wyodrębnienie głównej treści
+        article = soup.find("article")
+        if article:
+            content = article.get_text(separator="\n", strip=True)
+        else:
+            content = soup.get_text(separator="\n", strip=True)
+
+        # Wyodrębnienie metadanych
+        metadata = doc.metadata.copy() # Kopiujemy istniejące metadane (np. source)
+        
+        # Title: Zgodnie z sugestią, tytuł jest pobierany tylko ze znacznika <title>
+        if soup.title:
+            title_text = soup.title.get_text(strip=True)
+            if title_text:
+                metadata["title"] = title_text
+
+        # Data publikacji
+        # Published time: prefer meta[property=article:published_time], then <time>, then regex search
+        pub_date_tag = soup.find("meta", property="article:published_time")
+        if pub_date_tag and pub_date_tag.get("content"):
+            metadata["published_time"] = pub_date_tag["content"]
+        else:
+            time_tag = soup.find("time")
+            if time_tag and time_tag.get("datetime"):
+                metadata["published_time"] = time_tag.get("datetime")
+            elif time_tag and time_tag.get_text(strip=True):
+                metadata["published_time"] = time_tag.get_text(strip=True)
+            else:
+                # Polish pages often have 'Opublikowano w dniu 8 marca 2011' as plain text
+                text = soup.get_text(separator="\n", strip=True)
+                m = re.search(r"Opublikowano(?: w dniu)?[:\s]+([0-9]{1,2}\s+\w+\s+\d{4})", text, re.IGNORECASE)
+                if m:
+                    metadata["published_time"] = m.group(1)
+
+        # Kategorie
+        categories = [
+            tag["content"]
+            for tag in soup.find_all("meta", property="article:section")
+            if tag.get("content")
+        ]
+        if categories:
+            metadata["categories"] = ", ".join(categories)
+
+        # Słowa kluczowe (tagi)
+        keywords = [
+            tag["content"]
+            for tag in soup.find_all("meta", property="article:tag")
+            if tag.get("content")
+        ]
+        if keywords:
+            metadata["keywords"] = ", ".join(keywords)
+
+        
+
+        processed_docs.append(Document(page_content=content, metadata=metadata))
+    return processed_docs
+
+
+embedder=OpenAIEmbeddings(model="text-embedding-3-small", show_progress_bar=True)
+
+baza=Chroma(collection_name="szuflada", embedding_function=embedder, persist_directory="./szuflada")
+
+# --- DODANA SEKCJA ---
+# Czyszczenie istniejącej kolekcji przed dodaniem nowych danych
+# To zapewnia, że pracujemy na świeżych danych z metadanymi.
+print("Czyszczenie istniejącej kolekcji w bazie danych...")
+try:
+    baza.delete_collection()
+    print("Kolekcja została wyczyszczona.")
+    # Po usunięciu kolekcji, musimy ponownie zainicjować obiekt Chroma
+    baza=Chroma(collection_name="szuflada", embedding_function=embedder, persist_directory="./szuflada")
+except Exception as e:
+    print(f"Nie można było wyczyścić kolekcji (może nie istniała): {e}")
+# --- KONIEC DODANEJ SEKCJI ---
+
+
+
+# --- Nowa logika ładowania danych ---
+print("Pobieranie i parsowanie mapy strony...")
+headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
+sitemap_url = "https://mojaszuflada.pl/wp-sitemap.xml"
+docs = []
+
+try:
+    response = requests.get(sitemap_url, headers=headers)
+    response.raise_for_status()
+    sitemap_xml = response.text
+
+    sitemap_soup = BeautifulSoup(sitemap_xml, "xml")
+    urls = [loc.text for loc in sitemap_soup.find_all("loc")]
+
+    sitemap_urls = [url for url in urls if url.endswith(".xml")]
+    page_urls = [url for url in urls if not url.endswith(".xml")]
+
+    for sub_sitemap_url in tqdm(sitemap_urls, desc="Parsowanie pod-map"):
+        try:
+            response = requests.get(sub_sitemap_url, headers=headers)
+            response.raise_for_status()
+            sub_sitemap_xml = response.text
+            sub_sitemap_soup = BeautifulSoup(sub_sitemap_xml, "xml")
+            page_urls.extend([loc.text for loc in sub_sitemap_soup.find_all("loc")])
+        except requests.RequestException as e:
+            print(f"Pominięto pod-mapę {sub_sitemap_url}: {e}")
+
+    print(f"Znaleziono {len(page_urls)} adresów URL do przetworzenia.")
+
+    for url in tqdm(page_urls, desc="Pobieranie stron"):
+        try:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+            doc = Document(
+                page_content=response.text,
+                metadata={"source": url, "loc": url}
+            )
+            docs.append(doc)
+        except requests.RequestException as e:
+            print(f"Pominięto stronę {url}: {e}")
+
+except requests.RequestException as e:
+    print(f"Krytyczny błąd: Nie udało się pobrać głównej mapy strony: {e}")
+    # docs will be empty and the script will exit gracefully later
+
+if not docs:
+    print("Nie załadowano żadnych dokumentów. Zakończenie pracy.")
+    exit()
+
+
+processed_docs = process_documents(docs)
+
+print("\nPrzykładowe metadane przetworzonych dokumentów (pierwsze 5):")
+for pd in processed_docs[:5]:
+    print(pd.metadata)
+
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+chunks = text_splitter.split_documents(processed_docs)
+
+
+batch_size = 1000
+# --- WALIDACJA METADANYCH DLA CHUNKÓW ---
+# Sprawdzamy, czy każdy chunk zawiera oczekiwane metadane (źródło, tytuł, data publikacji)
+required_meta_keys = ["source", "title", "published_time"]
+missing_counts = {k: 0 for k in required_meta_keys}
+for idx, chunk in enumerate(chunks):
+    md = chunk.metadata or {}
+    for k in required_meta_keys:
+        if not md.get(k):
+            missing_counts[k] += 1
+
+print(f"Liczba chunków: {len(chunks)}")
+print("Braki metadanych (liczba chunków bez klucza/wartości):", missing_counts)
+print("Przykładowe metadane dla pierwszych 5 chunków:")
+for sample in chunks[:5]:
+    print(sample.metadata)
+# --- KONIEC WALIDACJI ---
+
+for i in range(0, len(chunks), batch_size):
+    baza.add_documents(documents=chunks[i:i + batch_size])
+