Aplikacja tworzy bazę po uruchomieniu

app.py

@@ -1,87 +1,20 @@
-import gradio as gr
+import sys
 import uuid
-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
-
-# --- 1. Inicjalizacja modeli i retrievera ---
-# Inicjalizacja modelu językowego oraz embeddera
-llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.0)
-embedder = OpenAIEmbeddings(model="text-embedding-3-small")
-# Inicjalizacja bazy Chroma z embeddingami
-baza = Chroma(
-    collection_name="szuflada",
-    embedding_function=embedder,
-    persist_directory="./szuflada"
-)
-# Możliwe typy wyszukiwania w retrieverze Chroma:
-# - "similarity" (domyślne, bez progu)
-# - "mmr" (Maximal Marginal Relevance)
-# - "similarity_score_threshold" (z progiem score_threshold)
-
-# Retriever do wyszukiwania podobnych fragmentów
-retriever = baza.as_retriever(
-    search_kwargs={"k": 3}
-)
-
-# --- 2. Tworzenie łańcucha RAG z historią ---
-# Prompt do kontekstualizacji pytania na podstawie historii czatu
-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}"),
-    ]
-)
-# Łańcuch do kontekstualizacji pytania z historią
-history_aware_retriever = create_history_aware_retriever(
-    llm, retriever, contextualize_q_prompt
-)
 
-# Prompt do generowania odpowiedzi na podstawie kontekstu
-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}"),
-    ]
-)
-# Łańcuch generujący odpowiedź na podstawie dokumentów
-question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)
-
-# Połączenie retrievera z generatorem odpowiedzi
-rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)
+import gradio as gr
 
-# Słownik do przechowywania historii czatu dla sesji
-store = {}
+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
 
-def get_session_history(session_id: str) -> BaseChatMessageHistory:
-    # Zwraca historię czatu dla danej sesji (tworzy jeśli nie istnieje)
-    if session_id not in store:
-        store[session_id] = ChatMessageHistory()
-    return store[session_id]
+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)
 
-# Łańcuch RAG z obsługą historii wiadomości
+rag_chain = create_rag_chain(baza)
+get_session_history = create_session_history_manager()
 conversational_rag_chain = RunnableWithMessageHistory(
     rag_chain,
     get_session_history,
@@ -90,42 +23,41 @@ conversational_rag_chain = RunnableWithMessageHistory(
     output_messages_key="answer",
 )
 
-# --- 3. Funkcje pomocnicze dla Gradio ---
-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 respond(message, chat_history, sess_id):
+    """Obsługuje odpowiedź na wiadomość użytkownika."""
+    try:
+        response = conversational_rag_chain.invoke(
+            {"input": message},
+            config={"configurable": {"session_id": sess_id}},
+        )
+    except Exception as e:
+        chat_history.append((message, f"Błąd podczas przetwarzania: {e}"))
+        return chat_history
+
+    context_docs = response.get("context", [])
+    # Debug: wypisz poziom podobieństwa
+    try:
+        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 = 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
 
-# --- 4. Budowa interfejsu Gradio ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Szuflada Chatbot") as demo:
     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](https://mojaszuflada.pl)
-        """
+        "# Czat z Moją Szufladą\n"
+        "### Zadaj pytanie na temat treści ze strony [mojaszuflada.pl](https://mojaszuflada.pl)"
     )
+    chatbot = gr.Chatbot(label="Rozmowa", height=500)
 
-    # Komponent czatu
-    chatbot = gr.Chatbot(
-        label="Rozmowa", 
-        height=500,
-    )
-    
-    # Pole tekstowe i przycisk do wysyłania wiadomości
     with gr.Row():
         msg = gr.Textbox(
             show_label=False,
@@ -135,39 +67,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Szuflada Chatbot
         )
         submit_btn = gr.Button("Wyślij", variant="primary", scale=1)
 
-    # Funkcja obsługująca odpowiedź na wiadomość użytkownika
-    def respond(message, chat_history, sess_id):
-        # Wywołanie łańcucha RAG z historią
-        response = conversational_rag_chain.invoke(
-            {"input": message},
-            config={"configurable": {"session_id": sess_id}},
-        )
-        context_docs = response.get("context", [])
-        # Debug: wypisz poziom podobieństwa dla znalezionych chunków
-        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')}")
-        sources_md = format_sources(context_docs)
-        answer = response.get("answer") or ""
-        answer_with_sources = answer + "\n\n**Źródła:**\n" + sources_md
-        chat_history.append((message, answer_with_sources))
-        return chat_history
-
-    # Obsługa kliknięcia przycisku "Wyślij"
-    submit_btn.click(
-        respond, 
-        [msg, chatbot, session_id], 
-        [chatbot]
-    ).then(lambda: gr.update(value=""), None, [msg], queue=False)
-
-    # Obsługa wysłania wiadomości enterem
-    msg.submit(
-        respond, 
-        [msg, chatbot, session_id], 
-        [chatbot]
-    ).then(lambda: gr.update(value=""), None, [msg], queue=False)
+    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)
 
-# --- 5. Uruchomienie aplikacji ---
 if __name__ == "__main__":
-    # Uruchom aplikację Gradio z publicznym linkiem
-    demo.launch(inbrowser=True)
+    demo.launch(inbrowser=True)

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

scrap.py

@@ -1,3 +1,4 @@
+# Ten plik jest odpowiedzialny za scrapowanie danych ze strony.
 from langchain_community.document_loaders import SitemapLoader
 from bs4 import BeautifulSoup
 import re
@@ -173,3 +174,4 @@ for sample in chunks[:5]:
 
 for i in range(0, len(chunks), batch_size):
     baza.add_documents(documents=chunks[i:i + batch_size])
+