new

.env

@@ -0,0 +1,3 @@
+ES_CLOUD_ID="a520864218294af499ed5aaf6e6e6cdd:dXMtY2VudHJhbDEuZ2NwLmNsb3VkLmVzLmlvOjQ0MyQ4NjBjMzk2NTM2MDI0YWRhOTFhZmVhM2U5ZWFhNjM0ZSQ0NWRkMmE4OWMzOTc0ZDk5YjkwZmYwZmU4NzVhYzRkZg=="
+ES_API_KEY="ZlpRWTFwZ0JONEp3Zzd4dy1FMnA6LU5zSkxIUlpqRjhYWk5WMm5IY2lQQQ=="
+TOGETHER_API_KEY="1cc34f3c51e78ab60ff3dd226cb5421cce92191da6c985c868ed5f56ff7eb987"

backendv1.py

@@ -1,11 +1,12 @@
 # backendv1.py
 # VÉGLEGES, JAVÍTOTT VERZIÓ: Elastic Cloud és GitHub Secrets kompatibilis.
 # A RAG rendszer motorja: adatfeldolgozás, keresés, generálás és tanulás.
+# JAVÍTVA: A kategória-alapú szűrés ideiglenesen kikapcsolva a megbízhatóbb eredmények érdekében.
 
 import os
 import time
 import datetime
-import json
+import traceback
 import re
 from collections import defaultdict
 from elasticsearch import Elasticsearch, exceptions as es_exceptions
@@ -35,7 +36,7 @@ CYAN = '\033[96m'
 MAGENTA = '\033[95m'
 
 # --- Konfiguráció ---
-# JAVÍTVA: A hitelesítő adatok már nincsenek itt, a program a környezeti változókból olvassa őket.
+# A hitelesítő adatok a környezeti változókból kerülnek beolvasásra.
 CONFIG = {
     "VECTOR_INDEX_NAMES": ["duna", "dunawebindexai"],
     "FEEDBACK_INDEX_NAME": "feedback_index",
@@ -122,8 +123,14 @@ def run_separate_searches(es_client, query_text, embedding_model, expanded_queri
     source_fields = ["text_content", "source_url", "summary", "category"]
     filters = []
     
-    if query_category and query_category != 'egyéb':
-        filters.append({"match": {"category": query_category}})
+    ### JAVÍTÁS ###
+    # A kategória-alapú szűrés ideiglenesen ki van kapcsolva, mert pontatlan
+    # kategorizálás esetén drasztikusan rontja a találatok minőségét.
+    # A keresés így a teljes adatbázisban fut, ami megbízhatóbb.
+    #
+    # if query_category and query_category != 'egyéb':
+    #     print(f"  {MAGENTA}-> Kategória-alapú szűrés hozzáadása a kereséshez: '{query_category}'{RESET}")
+    #     filters.append({"match": {"category": query_category}})
 
     def knn_search(index, query_vector):
         try:
@@ -347,7 +354,7 @@ def process_query(user_question, chat_history, backend, confidence_threshold, fa
         return {"answer": retrieved_context, "sources": [], "corrected_question": corrected_question, "confidence_score": confidence_score}
 
     system_prompt = f"""Te egy professzionális, segítőkész AI asszisztens vagy.
-A feladatod, hogy a KONTEXTUS-ból és a FEJLESZTŐI UTASÍTÁSOKBÓL származó információkat egyetlen, jól strukturált és ismétlés-mentes válasszá szintetizálld.
+A feladatod, hogy a KONTEXTUS-ból és a FEJLESZTŐI UTASÍTÁSOKBól származó információkat egyetlen, jól strukturált és ismétlés-mentes válasszá szintetizálld.
 {feedback_instructions}
 KRITIKUS SZABÁLY: Értékeld a kapott KONTEXTUS relevanciáját a felhasználó kérdéséhez képest. Ha egy kontextus-részlet nem kapcsolódik szorosan a kérdéshez, azt hagyd figyelmen kívül!
 FIGYELEM: Szigorúan csak a megadott KONTEXTUS-ra és a fejlesztői utasításokra támaszkodj. Ha a releváns információk alapján nem tudsz válaszolni, add ezt a választ: '{fallback_message}'
@@ -361,5 +368,4 @@ KONTEXTUS:
     
     answer = generate_answer_with_history(backend["llm_client"], CONFIG["TOGETHER_MODEL_NAME"], messages_for_llm, CONFIG["GENERATION_TEMPERATURE"])
     
-    return {"answer": answer, "sources": sources, "corrected_question": corrected_question, "confidence_score": confidence_score}
-
+    return {"answer": answer, "sources": sources, "corrected_question": corrected_question, "confidence_score": confidence_score}

web_indexer_universal_v7.py

@@ -1,5 +1,6 @@
 # web_indexer_universal_v7.py
-# VÉGLEGES VERZIÓ 2.0: Szinonimák nélkül, dinamikus AI kategorizálással.
+# EGYSZERŰSÍTETT VERZIÓ: A szinonima-kezelés teljesen eltávolítva.
+# Támogatja az Elastic Cloud-ot, biztonságos konfigurációkezeléssel.
 
 import os
 import time
@@ -8,35 +9,74 @@ import requests
 from bs4 import BeautifulSoup
 from urllib.parse import urljoin, urlparse
 from collections import deque
-from elasticsearch import Elasticsearch, helpers
+from elasticsearch import Elasticsearch, helpers, exceptions as es_exceptions
 import sys
+import warnings
+from dotenv import load_dotenv
 
-# === ANSI Színkódok ===
+# === ANSI Színkódok (konzol loggoláshoz) ===
 GREEN = '\033[92m'
 YELLOW = '\033[93m'
 RED = '\033[91m'
 RESET = '\033[0m'
+BLUE = '\033[94m'
 CYAN = '\033[96m'
+MAGENTA = '\033[95m'
+
+
+# --- Konfiguráció betöltése környezeti változókból ---
+load_dotenv()
+
+CONFIG = {
+    # --- Alap beállítások (felülírhatók .env fájlból) ---
+    "START_URL": os.getenv("START_URL", "https://www.dunaelektronika.com/"),
+    "MAX_DEPTH": int(os.getenv("MAX_DEPTH", 2)),
+    "REQUEST_DELAY": int(os.getenv("REQUEST_DELAY", 1)),
+    "USER_AGENT": os.getenv("USER_AGENT", "MyPythonCrawler/1.0 (+http://example.com/botinfo)"),
+    "VECTOR_INDEX_NAME": os.getenv("VECTOR_INDEX_NAME", "dunawebindexai"),
+    "BATCH_SIZE": int(os.getenv("BATCH_SIZE", 50)),
+    "ES_CLIENT_TIMEOUT": int(os.getenv("ES_CLIENT_TIMEOUT", 120)),
+    "EMBEDDING_MODEL_NAME": 'sentence-transformers/paraphrase-multilingual-mpnet-base-v2',
+    "CHUNK_SIZE_TOKENS": int(os.getenv("CHUNK_SIZE_TOKENS", 500)),
+    "CHUNK_OVERLAP_TOKENS": int(os.getenv("CHUNK_OVERLAP_TOKENS", 50)),
+    "MIN_CHUNK_SIZE_CHARS": int(os.getenv("MIN_CHUNK_SIZE_CHARS", 50)),
+    "LLM_MODEL_NAME": "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+    "LLM_CHUNK_MODEL": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "DEBUG_MODE": os.getenv("DEBUG_MODE", "True").lower() == 'true',
+
+    # --- Kötelező, érzékeny adatok ---
+    "ES_CLOUD_ID": os.getenv("ES_CLOUD_ID"),
+    "ES_API_KEY": os.getenv("ES_API_KEY"),
+    "TOGETHER_API_KEY": os.getenv("TOGETHER_API_KEY")
+}
+
+CONFIG["TARGET_DOMAIN"] = urlparse(CONFIG["START_URL"]).netloc
+
+embedding_model = None
+EMBEDDING_DIM = None
+device = 'cpu'
+together_client = None
 
-# --- Könyvtárak importálása és ellenőrzése ---
+# --- LLM és egyéb könyvtárak ellenőrzése és importálása ---
 try:
     import torch
     TORCH_AVAILABLE = True
 except ImportError:
     TORCH_AVAILABLE = False
+    print(f"{RED}FIGYELEM: Torch nincs telepítve.{RESET}")
 
 try:
     import together
-    from dotenv import load_dotenv
-    load_dotenv()
-    together_api_key = os.getenv("TOGETHER_API_KEY")
-    if not together_api_key:
-        print(f"{YELLOW}Figyelem: TOGETHER_API_KEY nincs beállítva, LLM funkciók nem működnek.{RESET}")
-        together_client = None
+    if not CONFIG["TOGETHER_API_KEY"]:
+        print(f"{RED}Hiba: TOGETHER_API_KEY nincs beállítva.{RESET}")
     else:
-        together_client = together.Together(api_key=together_api_key)
+        together_client = together.Together(api_key=CONFIG["TOGETHER_API_KEY"])
         print(f"{GREEN}Together AI kliens inicializálva.{RESET}")
 except ImportError:
+    print(f"{YELLOW}Figyelem: together könyvtár nincs telepítve.{RESET}")
+    together_client = None
+except Exception as e:
+    print(f"{RED}Hiba LLM backend inicializálásakor: {e}{RESET}")
     together_client = None
 
 try:
@@ -45,47 +85,118 @@ try:
     TIKTOKEN_AVAILABLE = True
 except ImportError:
     TIKTOKEN_AVAILABLE = False
+    print(f"{YELLOW}Figyelem: tiktoken nincs telepítve.{RESET}")
 
 try:
     import nltk
     try:
         nltk.data.find('tokenizers/punkt')
     except LookupError:
-        print(f"{CYAN}NLTK 'punkt' letöltése...{RESET}")
+        print(f"{CYAN}NLTK 'punkt' letöltése...{RESET}");
         nltk.download('punkt', quiet=True)
     NLTK_AVAILABLE = True
 except ImportError:
     NLTK_AVAILABLE = False
+    print(f"{RED}HIBA: 'nltk' nincs telepítve!{RESET}")
 
 try:
     from sentence_transformers import SentenceTransformer
     SENTENCE_TRANSFORMER_AVAILABLE = True
 except ImportError:
     SENTENCE_TRANSFORMER_AVAILABLE = False
+    print(f"{RED}HIBA: 'sentence-transformers' nincs telepítve!{RESET}")
 
-# --- Konfiguráció ---
-ES_CLOUD_ID = os.getenv("ES_CLOUD_ID")
-ES_API_KEY = os.getenv("ES_API_KEY")
+try:
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+except AttributeError:
+    pass
+
+# --- LLM HÁTTÉR FUNKCIÓK ---
+def generate_categories_with_llm(llm_client, soup, text):
+    category_list = ['IT biztonsági szolgáltatások', 'szolgáltatások', 'hardver', 'szoftver', 'hírek', 'audiovizuális konferenciatechnika']
+    try:
+        breadcrumb = soup.find('nav', class_='breadcrumb')
+        if breadcrumb:
+            categories = [li.get_text(strip=True) for li in breadcrumb.find_all('li')]
+            if categories:
+                final_category_from_html = categories[-1]
+                for cat in category_list:
+                    if cat.lower() in final_category_from_html.lower():
+                        return [cat]
+    except Exception: pass
+    try:
+        h1_tag = soup.find('h1')
+        if h1_tag and h1_tag.get_text(strip=True):
+            h1_text = h1_tag.get_text(strip=True)
+            for cat in category_list:
+                if cat.lower() in h1_text.lower():
+                    return [cat]
+    except Exception: pass
+    if not llm_client: return ['egyéb']
+    try:
+        categories_text = ", ".join([f"'{cat}'" for cat in category_list])
+        prompt = f"""Adott egy weboldal szövege. Adj meg egyetlen, rövid kategóriát a következő listából, ami a legjobban jellemzi a tartalmát. A válaszodban csak a kategória szerepeljen, más szöveg nélkül.
+Lehetséges kategóriák: {categories_text}
+Szöveg: {text[:1000]}
+Kategória:"""
+        response = llm_client.chat.completions.create(model=CONFIG["LLM_CHUNK_MODEL"], messages=[{"role": "user", "content": prompt}], temperature=0.1, max_tokens=30)
+        if response and response.choices:
+            category = response.choices[0].message.content.strip().replace("'", "").replace("`", "")
+            for cat in category_list:
+                if cat.lower() in category.lower():
+                    return [cat]
+    except Exception as e:
+        print(f"{RED}Hiba LLM kategorizáláskor: {e}{RESET}")
+    return ['egyéb']
 
-START_URL = "https://www.dunaelektronika.com/"
-TARGET_DOMAIN = "dunaelektronika.com"
-MAX_DEPTH = 2
-REQUEST_DELAY = 1
-USER_AGENT = "MyPythonCrawler/1.0"
-VECTOR_INDEX_NAME = "dunawebindexai"
-BATCH_SIZE = 50
-ES_CLIENT_TIMEOUT = 120
-EMBEDDING_MODEL_NAME = 'sentence-transformers/paraphrase-multilingual-mpnet-base-v2'
-embedding_model = None
-EMBEDDING_DIM = 768  # Alapértelmezett, betöltés után frissítjük
-device = 'cpu'
-CHUNK_SIZE_TOKENS = 500
-CHUNK_OVERLAP_TOKENS = 50
-MIN_CHUNK_SIZE_CHARS = 50
-LLM_CHUNK_MODEL = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+def generate_summary_with_llm(llm_client, text):
+    if not llm_client: return text[:300] + "..."
+    try:
+        prompt = f"""Készíts egy rövid, de informatív összefoglalót a következő szövegről. A lényeges pontokat emeld ki, de ne lépd túl a 200 szó terjedelmet.
+Szöveg: {text}
+Összefoglalás:"""
+        response = llm_client.chat.completions.create(model=CONFIG["LLM_CHUNK_MODEL"], messages=[{"role": "user", "content": prompt}], temperature=0.5, max_tokens=500)
+        if response and response.choices:
+            return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"{RED}Hiba LLM összefoglaláskor: {e}{RESET}")
+    return text[:300] + "..."
+
+def chunk_text_by_tokens(text, chunk_size, chunk_overlap):
+    if not TIKTOKEN_AVAILABLE or not NLTK_AVAILABLE:
+        chunks = []; start = 0
+        while start < len(text):
+            end = start + chunk_size; chunks.append(text[start:end]); start += chunk_size - chunk_overlap
+        return chunks
+    tokens = tiktoken_encoder.encode(text); chunks = []; start = 0
+    while start < len(tokens):
+        end = start + chunk_size; chunk_tokens = tokens[start:end]; chunks.append(tiktoken_encoder.decode(chunk_tokens)); start += chunk_size - chunk_overlap
+    return chunks
+
+# --- Modellek és Eszközök Inicializálása ---
+def load_embedding_model():
+    global embedding_model, EMBEDDING_DIM, device
+    if not TORCH_AVAILABLE or not SENTENCE_TRANSFORMER_AVAILABLE: EMBEDDING_DIM = 768; device = 'cpu'; return None, EMBEDDING_DIM, device
+    if embedding_model and EMBEDDING_DIM: return embedding_model, EMBEDDING_DIM, device
+    print(f"\n'{CONFIG['EMBEDDING_MODEL_NAME']}' modell betöltése...")
+    try:
+        current_device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        model = SentenceTransformer(CONFIG['EMBEDDING_MODEL_NAME'], device=current_device)
+        print(f"ST modell betöltve, eszköz: {model.device}")
+        dim = model.get_sentence_embedding_dimension()
+        if not dim: raise ValueError("Dim error")
+        embedding_model = model; EMBEDDING_DIM = dim; device = current_device
+        return embedding_model, EMBEDDING_DIM, device
+    except Exception as e:
+        print(f"{RED}Hiba embedding modell betöltésekor: {e}{RESET}"); traceback.print_exc()
+        embedding_model = None; EMBEDDING_DIM = 768; device = 'cpu'
+        return None, EMBEDDING_DIM, device
 
-# === Index Beállítások & Mapping (EGYSZERŰSÍTETT, SZINONIMÁK NÉLKÜL) ===
-INDEX_SETTINGS_SIMPLE = {
+embedding_model, EMBEDDING_DIM, device = load_embedding_model()
+
+# === Index Beállítások & Mapping (Szinonimák nélkül) ===
+INDEX_SETTINGS = {
     "analysis": {
         "filter": {
             "hungarian_stop": {"type": "stop", "stopwords": "_hungarian_"},
@@ -99,15 +210,14 @@ INDEX_SETTINGS_SIMPLE = {
         }
     }
 }
-
-INDEX_MAPPINGS_SIMPLE = {
+INDEX_MAPPINGS_WEB = {
     "properties": {
         "text_content": {"type": "text", "analyzer": "hungarian_analyzer"},
         "embedding": {"type": "dense_vector", "dims": EMBEDDING_DIM, "index": True, "similarity": "cosine"},
         "source_origin": {"type": "keyword"},
         "source_url": {"type": "keyword"},
         "source_type": {"type": "keyword"},
-        "category": {"type": "keyword"}, # A 'keyword' típus listákat is tud kezelni
+        "category": {"type": "keyword"},
         "heading": {"type": "text", "analyzer": "hungarian_analyzer"},
         "summary": {"type": "text", "analyzer": "hungarian_analyzer"}
     }
@@ -115,267 +225,177 @@ INDEX_MAPPINGS_SIMPLE = {
 
 # --- Segédfüggvények ---
 def initialize_es_client():
-    print(f"\n{CYAN}Kapcsolódás az Elasticsearch-hez...{RESET}")
-    if not ES_CLOUD_ID or not ES_API_KEY:
-        print(f"{RED}Hiba: ES_CLOUD_ID vagy ES_API_KEY hiányzik a GitHub Secrets-ből!{RESET}")
+    if not CONFIG["ES_CLOUD_ID"] or not CONFIG["ES_API_KEY"]:
+        print(f"{RED}Hiba: Az ES_CLOUD_ID és ES_API_KEY környezeti változók beállítása kötelező!{RESET}")
         return None
     try:
+        if CONFIG["DEBUG_MODE"]: print("\nKapcsolódás az Elasticsearch-hez (Cloud ID)...")
         client = Elasticsearch(
-            cloud_id=ES_CLOUD_ID,
-            api_key=ES_API_KEY,
-            request_timeout=ES_CLIENT_TIMEOUT
+            cloud_id=CONFIG["ES_CLOUD_ID"],
+            api_key=CONFIG["ES_API_KEY"],
+            request_timeout=CONFIG["ES_CLIENT_TIMEOUT"]
         )
-        if not client.ping(): raise ConnectionError("Ping sikertelen.")
-        print(f"{GREEN}Sikeres Elasticsearch kapcsolat!{RESET}")
-        return client
+        if client.ping():
+            if CONFIG["DEBUG_MODE"]: print(f"{GREEN}Sikeres Elastic Cloud kapcsolat!{RESET}")
+            return client
     except Exception as e:
-        print(f"{RED}Hiba az Elasticsearch kapcsolódás során: {e}{RESET}")
-        return None
-
-def load_embedding_model():
-    global embedding_model, EMBEDDING_DIM, device
-    if not (TORCH_AVAILABLE and SENTENCE_TRANSFORMER_AVAILABLE):
-        print(f"{RED}PyTorch vagy SentenceTransformer nincs telepítve. Embedding nem működik.{RESET}")
-        return
-    
-    print(f"\n{CYAN}'{EMBEDDING_MODEL_NAME}' embedding modell betöltése...{RESET}")
-    try:
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        model = SentenceTransformer(EMBEDDING_MODEL_NAME, device=device)
-        embedding_model = model
-        EMBEDDING_DIM = model.get_sentence_embedding_dimension()
-        INDEX_MAPPINGS_SIMPLE["properties"]["embedding"]["dims"] = EMBEDDING_DIM
-        print(f"{GREEN}Embedding modell betöltve (dim: {EMBEDDING_DIM}, eszköz: {device}).{RESET}")
-    except Exception as e:
-        print(f"{RED}Hiba az embedding modell betöltésekor: {e}{RESET}")
-        embedding_model = None
-
-def generate_dynamic_categories_with_llm(llm_client, soup, text):
-    if not llm_client: return ["általános"]
-    
-    h1_text = ""
-    try:
-        h1_tag = soup.find('h1')
-        if h1_tag:
-            h1_text = h1_tag.get_text(strip=True)
-    except Exception:
-        pass
-
-    try:
-        prompt = f"""Elemezd a következő magyar nyelvű weboldal tartalmát, és adj meg 1-3 rövid, releváns kategóriát vagy címkét, ami a legjobban leírja azt. A kategóriákat vesszővel válaszd el. A válaszodban csak a kategóriák szerepeljenek, más magyarázat nélkül.
-Weboldal címe: "{h1_text}"
-Szöveg eleje: {text[:1500]}
-Kategóriák:"""
-        
-        response = llm_client.chat.completions.create(
-            model=LLM_CHUNK_MODEL,
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.2,
-            max_tokens=50
-        )
-        
-        if response and response.choices:
-            categories_str = response.choices[0].message.content.strip()
-            # A válasz feldolgozása: vessző mentén darabolás, felesleges szóközök eltávolítása, kisbetűsítés
-            categories = [cat.strip().lower() for cat in categories_str.split(',') if cat.strip()]
-            print(f"{GREEN}    -> Dinamikus kategóriák az AI alapján: {categories}{RESET}")
-            return categories if categories else ["általános"]
-        return ["általános"]
-    except Exception as e:
-        print(f"{RED}Hiba a dinamikus LLM kategorizáláskor: {e}{RESET}")
-        return ["általános"]
-
-def generate_summary_with_llm(llm_client, text):
-    if not llm_client: return text[:300] + "..."
-    try:
-        prompt = f"""Készíts egy rövid, de informatív összefoglalót a következő szövegről magyarul.
-Szöveg: {text[:4000]}
-Összefoglalás:"""
-        response = llm_client.chat.completions.create(model=LLM_CHUNK_MODEL, messages=[{"role": "user", "content": prompt}], temperature=0.5, max_tokens=500)
-        if response and response.choices:
-            summary = response.choices[0].message.content.strip()
-            print(f"{GREEN}    -> Sikeres LLM összefoglalás generálás.{RESET}")
-            return summary
-    except Exception as e:
-        print(f"{RED}Hiba LLM összefoglaláskor: {e}{RESET}")
-    return text[:300] + "..."
-
-def chunk_text_by_tokens(text, chunk_size, chunk_overlap):
-    if not TIKTOKEN_AVAILABLE:
-        chunks, start = [], 0
-        while start < len(text):
-            end = start + (chunk_size * 4)
-            chunks.append(text[start:end])
-            start = end - (chunk_overlap * 4)
-        return chunks
-    tokens = tiktoken_encoder.encode(text)
-    chunks, start = [], 0
-    while start < len(tokens):
-        end = start + chunk_size
-        chunk_tokens = tokens[start:end]
-        chunks.append(tiktoken_encoder.decode(chunk_tokens))
-        start += chunk_size - chunk_overlap
-    return chunks
+        print(f"{RED}Hiba az Elastic Cloud kapcsolat során: {e}{RESET}")
+    return None
 
 def get_embedding(text):
-    if not embedding_model: return None
+    if not embedding_model or not text or not isinstance(text, str): return None
     try:
         return embedding_model.encode(text, normalize_embeddings=True).tolist()
     except Exception as e:
-        print(f"{RED}Hiba embedding közben: {e}{RESET}")
-        return None
+        print(f"{RED}Hiba embedding közben: {e}{RESET}"); return None
 
 def create_es_index(client, index_name, index_settings, index_mappings):
-    print(f"\n{CYAN}Index ellenőrzése: '{index_name}'...{RESET}")
+    if not EMBEDDING_DIM:
+        print(f"{RED}Hiba: Embedding dimenzió nincs beállítva.{RESET}")
+        return False
+    try:
+        index_mappings["properties"]["embedding"]["dims"] = EMBEDDING_DIM
+    except KeyError:
+        print(f"{RED}Hiba: Érvénytelen mapping struktúra.{RESET}")
+        return False
     try:
         if not client.indices.exists(index=index_name):
             print(f"'{index_name}' index létrehozása...")
             client.indices.create(index=index_name, settings=index_settings, mappings=index_mappings)
             print(f"{GREEN}Index sikeresen létrehozva.{RESET}")
+            time.sleep(2)
         else:
-            print(f"Index '{index_name}' már létezik.")
+            if CONFIG["DEBUG_MODE"]: print(f"Index '{index_name}' már létezik.")
         return True
     except Exception as e:
-        print(f"{RED}!!! Hiba az index létrehozásakor: {e}{RESET}")
+        print(f"{RED}Hiba az index létrehozása során: {e}{RESET}")
+        traceback.print_exc()
         return False
 
 def extract_text_from_html(html_content):
     try:
         soup = BeautifulSoup(html_content, 'html.parser')
         for element in soup(["script", "style", "nav", "footer", "header", "aside", "form"]):
-            element.decompose()
-        main_content = soup.find('main') or soup.find('article') or soup.body or soup
-        text = main_content.get_text(separator='\n', strip=True)
-        return "\n".join(line for line in text.splitlines() if line.strip())
+            if element: element.decompose()
+        main_content = soup.find('main') or soup.find('article') or soup.body
+        if main_content:
+            return "\n".join(line for line in main_content.get_text(separator='\n', strip=True).splitlines() if line.strip())
     except Exception as e:
-        print(f"{RED}Hiba a HTML tartalom kinyerésekor: {e}{RESET}")
+        print(f"{RED}Hiba a HTML szöveg kinyerése során: {e}{RESET}")
     return ""
 
 def extract_and_filter_links(soup, base_url, target_domain):
     links = set()
-    for a_tag in soup.find_all('a', href=True):
-        href = a_tag['href'].strip()
-        if href and not href.startswith(('#', 'mailto:', 'javascript:')):
-            full_url = urljoin(base_url, href)
-            parsed_url = urlparse(full_url)
-            if parsed_url.scheme in ['http', 'https'] and parsed_url.netloc == target_domain:
-                links.add(parsed_url._replace(fragment="").geturl())
+    try:
+        for a_tag in soup.find_all('a', href=True):
+            href = a_tag['href'].strip()
+            if href and not href.startswith(('#', 'mailto:', 'javascript:')):
+                full_url = urljoin(base_url, href)
+                parsed_url = urlparse(full_url)
+                if parsed_url.scheme in ['http', 'https'] and parsed_url.netloc == target_domain:
+                    links.add(parsed_url._replace(fragment="").geturl())
+    except Exception as e:
+        print(f"{RED}Hiba a linkek kinyerése során: {e}{RESET}")
     return links
 
 def crawl_and_index_website(start_url, max_depth, es_client, index_name):
+    if not es_client or not embedding_model: return 0
     visited_urls, urls_to_visit = set(), deque([(start_url, 0)])
-    bulk_actions, total_indexed = [], 0
+    bulk_actions = []
+    total_prepared, total_indexed = 0, 0
     target_domain = urlparse(start_url).netloc
     print(f"Web crawling indítása: {start_url} (Max mélység: {max_depth}, Cél: {target_domain})")
-
     while urls_to_visit:
+        current_url = None
         try:
             current_url, current_depth = urls_to_visit.popleft()
-        except IndexError:
-            break # Nincs több URL a listában
-
-        if current_url in visited_urls:
-            continue
-        
-        print(f"\n--- Feldolgozás (Mélység: {current_depth}): {current_url} ---")
-        visited_urls.add(current_url)
-
-        try:
-            headers = {'User-Agent': USER_AGENT}
-            response = requests.get(current_url, headers=headers, timeout=15)
-            response.raise_for_status()
-            if 'text/html' not in response.headers.get('content-type', '').lower():
-                print(f"  {YELLOW}-> Nem HTML tartalom, kihagyva.{RESET}")
-                continue
-            
-            html_content = response.content
+            if current_url in visited_urls or current_depth > max_depth: continue
+            print(f"\n--- Feldolgozás (Mélység: {current_depth}): {current_url} ---")
+            visited_urls.add(current_url)
+            try:
+                headers = {'User-Agent': CONFIG["USER_AGENT"]}
+                response = requests.get(current_url, headers=headers, timeout=15)
+                response.raise_for_status()
+                if 'text/html' not in response.headers.get('content-type', '').lower():
+                    print(f"  {YELLOW}-> Nem HTML tartalom, kihagyva.{RESET}"); continue
+                html_content = response.content
+            except requests.exceptions.RequestException as req_err:
+                print(f"  {RED}!!! Hiba a letöltés során: {req_err}{RESET}"); continue
             soup = BeautifulSoup(html_content, 'html.parser')
             page_text = extract_text_from_html(html_content)
-
-            if not page_text or len(page_text) < MIN_CHUNK_SIZE_CHARS:
-                print(f"  {YELLOW}-> Nem sikerült szöveget kinyerni vagy túl rövid.{RESET}")
-                continue
-            
-            final_chunks = chunk_text_by_tokens(page_text, CHUNK_SIZE_TOKENS, CHUNK_OVERLAP_TOKENS)
-            categories = generate_dynamic_categories_with_llm(together_client, soup, page_text)
+            if not page_text or len(page_text) < CONFIG["MIN_CHUNK_SIZE_CHARS"]:
+                print(f"  {YELLOW}-> Túl rövid szöveg, kihagyva.{RESET}"); continue
+            final_chunks = chunk_text_by_tokens(page_text, CONFIG["CHUNK_SIZE_TOKENS"], CONFIG["CHUNK_OVERLAP_TOKENS"])
+            url_category = generate_categories_with_llm(together_client, soup, page_text)[0]
             page_summary = generate_summary_with_llm(together_client, page_text)
-            
-            print(f"{GREEN}    Indexelésre előkészítve: {len(final_chunks)} darab (Kategóriák: {categories}){RESET}")
-            
+            if not final_chunks: continue
             for chunk_text in final_chunks:
                 element_vector = get_embedding(chunk_text)
                 if element_vector:
-                    doc = {
-                        "text_content": chunk_text, "embedding": element_vector, "source_origin": "website",
-                        "source_url": current_url, "source_type": "token_chunking", 
-                        "category": categories, "summary": page_summary, "heading": soup.find('h1').get_text(strip=True) if soup.find('h1') else ''
-                    }
+                    total_prepared += 1
+                    doc = {"text_content": chunk_text, "embedding": element_vector, "source_origin": "website", "source_url": current_url, "source_type": "token_chunking", "category": url_category, "summary": page_summary}
                     bulk_actions.append({"_index": index_name, "_source": doc})
-            
-            if len(bulk_actions) >= BATCH_SIZE:
-                print(f"    -> {len(bulk_actions)} chunk indexelése (batch)...")
-                success_count, _ = helpers.bulk(es_client, bulk_actions)
-                total_indexed += success_count
-                bulk_actions = []
-
+                    if len(bulk_actions) >= CONFIG["BATCH_SIZE"]:
+                        success_count, errors = helpers.bulk(es_client, bulk_actions, raise_on_error=False, request_timeout=CONFIG["ES_CLIENT_TIMEOUT"])
+                        total_indexed += success_count; bulk_actions = []
+                        if errors: print(f"{RED}!!! Hiba a bulk indexelés során: {len(errors)} sikertelen.{RESET}")
             if current_depth < max_depth:
-                new_links = extract_and_filter_links(soup, start_url, target_domain)
+                new_links = extract_and_filter_links(soup, current_url, target_domain)
                 for link in new_links:
-                    if link not in visited_urls:
-                        urls_to_visit.append((link, current_depth + 1))
-            
-            time.sleep(REQUEST_DELAY)
-
-        except requests.exceptions.RequestException as req_err:
-            print(f"  {RED}!!! Hiba a letöltés során: {req_err}{RESET}")
-        except Exception as e:
-            print(f"  {RED}!!! Váratlan hiba a ciklusban ({current_url}): {e}{RESET}")
-
+                    if link not in visited_urls: urls_to_visit.append((link, current_depth + 1))
+            time.sleep(CONFIG['REQUEST_DELAY'])
+        except KeyboardInterrupt: print("\nFolyamat megszak��tva."); break
+        except Exception as loop_err: print(f"{RED}!!! Hiba a ciklusban ({current_url}): {loop_err}{RESET}"); traceback.print_exc(); time.sleep(5)
     if bulk_actions:
-        print(f"    -> Maradék {len(bulk_actions)} chunk indexelése...")
-        success_count, _ = helpers.bulk(es_client, bulk_actions)
+        success_count, errors = helpers.bulk(es_client, bulk_actions, raise_on_error=False, request_timeout=CONFIG["ES_CLIENT_TIMEOUT"])
         total_indexed += success_count
-
-    print(f"\n--- Web Crawling és Indexelés Befejezve ---")
+        if errors: print(f"{RED}!!! Hiba a maradék indexelése során: {len(errors)} sikertelen.{RESET}")
+    print(f"\n--- Web Crawling Befejezve ---")
     print(f"Meglátogatott URL-ek: {len(visited_urls)}")
-    print(f"Sikeresen indexelt chunkok: {total_indexed}")
+    print(f"Előkészített chunk-ok: {total_prepared}")
+    print(f"Sikeresen indexelt chunk-ok: {total_indexed}")
     return total_indexed
 
-# === Fő Program ===
+# --- Fő futtatási blokk ---
 if __name__ == "__main__":
-    print("----- Web Crawler és Indexelő Indítása (Dinamikus AI Kategorizálással) -----")
-    
-    load_embedding_model()
+    print(f"----- Web Crawler és Indexelő Indítása a '{CONFIG['VECTOR_INDEX_NAME']}' indexbe -----")
+    print(f"----- Cél URL: {CONFIG['START_URL']} (Max mélység: {CONFIG['MAX_DEPTH']}) -----")
+    print("****** FIGYELEM ******")
+    print(f"Ez a script létrehozza/használja a '{CONFIG['VECTOR_INDEX_NAME']}' indexet.")
+    print(f"{RED}Ha a '{CONFIG['VECTOR_INDEX_NAME']}' index már létezik, TÖRÖLD manuálisan futtatás előtt!{RESET}")
+    print("********************")
+    if not all([TORCH_AVAILABLE, SENTENCE_TRANSFORMER_AVAILABLE, embedding_model, EMBEDDING_DIM]):
+        print(f"{RED}Hiba: AI modellek hiányoznak. Leállás.{RESET}"); exit(1)
+    if not CONFIG["TOGETHER_API_KEY"]:
+        print(f"{RED}Hiba: TOGETHER_API_KEY hiányzik. Leállás.{RESET}"); exit(1)
     
-    if not embedding_model:
-        print(f"{RED}Hiba: Az embedding modell betöltése sikertelen. A program leáll.{RESET}")
-        sys.exit(1)
-
     es_client = initialize_es_client()
-
-    if es_client:
-        try:
-            if es_client.indices.exists(index=VECTOR_INDEX_NAME):
-                print(f"{YELLOW}A '{VECTOR_INDEX_NAME}' index már létezik. Törlés...{RESET}")
-                es_client.indices.delete(index=VECTOR_INDEX_NAME)
-                print(f"{GREEN}Index sikeresen törölve.{RESET}")
-            
-            index_ready = create_es_index(
-                client=es_client, 
-                index_name=VECTOR_INDEX_NAME,
-                index_settings=INDEX_SETTINGS_SIMPLE,
-                index_mappings=INDEX_MAPPINGS_SIMPLE
-            )
-            
-            if index_ready:
-                final_success_count = crawl_and_index_website(START_URL, MAX_DEPTH, es_client, VECTOR_INDEX_NAME)
-                if final_success_count > 0:
-                     print(f"\n{GREEN}A folyamat sikeresen lefutott. {final_success_count} dokumentum indexelve.{RESET}")
-                else:
-                    print(f"\n{YELLOW}A folyamat lefutott, de 0 új dokumentum került indexelésre.{RESET}")
-            else:
-                print(f"{RED}Hiba: Az index nem áll készen a használatra.{RESET}")
-        except Exception as e:
-            print(f"{RED}Hiba a fő programrészben: {e}{RESET}")
+    if not es_client:
+        print(f"{RED}Hiba: Elasticsearch kliens inicializálása sikertelen. Leállás.{RESET}"); exit(1)
+
+    final_success_count = 0
+    index_ready = create_es_index(
+        client=es_client, 
+        index_name=CONFIG["VECTOR_INDEX_NAME"],
+        index_settings=INDEX_SETTINGS,
+        index_mappings=INDEX_MAPPINGS_WEB
+    )
+
+    if index_ready:
+        print(f"\nIndex '{CONFIG['VECTOR_INDEX_NAME']}' kész. Crawling indítása...")
+        final_success_count = crawl_and_index_website(
+            start_url=CONFIG["START_URL"],
+            max_depth=CONFIG["MAX_DEPTH"],
+            es_client=es_client,
+            index_name=CONFIG["VECTOR_INDEX_NAME"]
+        )
+    else:
+        print(f"{RED}Hiba: Index létrehozása sikertelen. Leállás.{RESET}")
+    
+    print("\n----- Feldolgozás Befejezve -----")
+    if index_ready and final_success_count > 0:
+        print(f"\n{GREEN}Sikeres. {final_success_count} chunk indexelve '{CONFIG['VECTOR_INDEX_NAME']}'-be.{RESET}")
+    elif index_ready and final_success_count == 0:
+        print(f"{YELLOW}Crawling lefutott, de 0 chunk lett indexelve.{RESET}")
     else:
-        print(f"{RED}Hiba: Az Elasticsearch kliens nem elérhető.{RESET}")
+        print(f"{RED}A folyamat hibával zárult.{RESET}")