Fix: Clean up requirements.txt to resolve build conflicts

web_indexer_universal_v7.py

@@ -1,6 +1,5 @@
 # web_indexer_universal_v7.py
-# JAVÍTVA: A hitelesítő adatok és a konfiguráció a GitHub Actions Secrets-ből érkeznek.
-# Robusztusabb logikával, a backendből importált funkciók helyett.
+# VÉGLEGES VERZIÓ: GitHub Secrets integrációval és a feltöltött szinonima készlet használatával.
 
 import os
 import time
@@ -18,86 +17,65 @@ GREEN = '\033[92m'
 YELLOW = '\033[93m'
 RED = '\033[91m'
 RESET = '\033[0m'
-BLUE = '\033[94m'
 CYAN = '\033[96m'
-MAGENTA = '\033[95m'
 
-# --- LLM és egyéb könyvtárak ellenőrzése és importálása ---
+# --- Könyvtárak importálása ---
 try:
     import torch
     TORCH_AVAILABLE = True
 except ImportError:
     TORCH_AVAILABLE = False
-    print(f"{RED}FIGYELEM: Torch nincs telepítve. Egyes funkciók nem működnek.{RESET}")
+    print(f"{RED}FIGYELEM: Torch nincs telepítve.{RESET}")
 
 try:
     import together
     from dotenv import load_dotenv
-
-    load_dotenv()
-    # <<< JAVÍTVA: A together_api_key betöltése a környezeti változókból
+    load_dotenv() # Helyi fejlesztéshez (.env fájl)
     together_api_key = os.getenv("TOGETHER_API_KEY")
     if not together_api_key:
-        print(f"{RED}Hiba: TOGETHER_API_KEY környezeti változó nincs beállítva. LLM funkciók nem működnek.{RESET}")
+        print(f"{YELLOW}Figyelem: TOGETHER_API_KEY környezeti változó nincs beállítva. LLM funkciók nem működnek.{RESET}")
         together_client = None
     else:
         together_client = together.Together(api_key=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. LLM funkciók nem fognak működni.{RESET}")
-    together_client = None
-except Exception as e:
-    print(f"{RED}Hiba LLM backend inicializálásakor: {e}{RESET}")
     together_client = None
 
-# ... (a többi import változatlan)
 try:
     import tiktoken
     tiktoken_encoder = tiktoken.get_encoding("cl100k_base")
     TIKTOKEN_AVAILABLE = True
 except ImportError:
     TIKTOKEN_AVAILABLE = False
-    print(f"{YELLOW}Figyelem: tiktoken nincs telepítve. Token darabolás a beállított karakterszámmal történik.{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! Szövegtördelés nem lesz pontos.{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! Embedding nem működik.{RESET}")
-
-try:
-    sys.stdout.reconfigure(encoding='utf-8')
-    sys.stderr.reconfigure(encoding='utf-8')
-except AttributeError:
-    print(f"{YELLOW}Figyelem: Kódolás beállítása nem sikerült.{RESET}")
 
 # --- Konfiguráció ---
-# <<< JAVÍTVA: A hitelesítő adatok betöltése környezeti változókból
-# Ezeket a GitHub Actions Secrets-ben kell beállítanod!
+# Adatok betöltése környezeti változókból (a GitHub Actions a Secrets-ből adja át)
 ES_CLOUD_ID = os.getenv("ES_CLOUD_ID")
 ES_API_KEY = os.getenv("ES_API_KEY")
-# A TOGETHER_API_KEY már korábban betöltésre került
 
 START_URL = "https://www.dunaelektronika.com/"
 TARGET_DOMAIN = "dunaelektronika.com"
 MAX_DEPTH = 2
 REQUEST_DELAY = 1
-USER_AGENT = "MyPythonCrawler/1.0 (+http://example.com/botinfo)"
+USER_AGENT = "MyPythonCrawler/1.0"
 VECTOR_INDEX_NAME = "dunawebindexai"
-SYNONYM_FILE_PATH_IN_ES_CONFIG = "analysis/synonyms_hu.txt"
 BATCH_SIZE = 50
 ES_CLIENT_TIMEOUT = 120
 EMBEDDING_MODEL_NAME = 'sentence-transformers/paraphrase-multilingual-mpnet-base-v2'
@@ -108,36 +86,122 @@ CHUNK_SIZE_TOKENS = 500
 CHUNK_OVERLAP_TOKENS = 50
 MIN_CHUNK_SIZE_CHARS = 50
 DEBUG_MODE = True
-LLM_MODEL_NAME = "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free"
 LLM_CHUNK_MODEL = "mistralai/Mixtral-8x7B-Instruct-v0.1"
 
 
-# --- LLM HÁTTÉR FUNKCIÓK ---
-# ... (ez a rész változatlan)
+# === Index Beállítások & Mapping ===
+# <<< JAVÍTVA: Ez a verzió már a Kibana-ban létrehozott "synonyms-hu" készletre hivatkozik
+INDEX_SETTINGS_SEPARATE_ANALYZER = {
+    "analysis": {
+        "filter": {
+            "hungarian_stop": {"type": "stop", "stopwords": "_hungarian_"},
+            "hungarian_stemmer": {"type": "stemmer", "language": "hungarian"},
+            "synonym_filter": {
+                "type": "synonym_graph",
+                "synonyms_set": "synonyms-hu" # Hivatkozás a feltöltött szinonima készletre
+            }
+        },
+        "analyzer": {
+            "hungarian_indexing_analyzer": {
+                "tokenizer": "standard",
+                "filter": ["lowercase", "hungarian_stop", "hungarian_stemmer"]
+            },
+            "hungarian_search_analyzer": {
+                "tokenizer": "standard",
+                "filter": ["lowercase", "hungarian_stop", "synonym_filter", "hungarian_stemmer"]
+            }
+        }
+    }
+}
+
+INDEX_MAPPINGS_WEB = {
+    "properties": {
+        "text_content": {"type": "text", "analyzer": "hungarian_indexing_analyzer", "search_analyzer": "hungarian_search_analyzer"},
+        "embedding": {"type": "dense_vector", "dims": 768, "index": True, "similarity": "cosine"}, # Dimenziót betöltés után frissítjük
+        "source_origin": {"type": "keyword"},
+        "source_url": {"type": "keyword"},
+        "source_type": {"type": "keyword"},
+        "category": {"type": "keyword"},
+        "heading": {"type": "text", "analyzer": "hungarian_indexing_analyzer", "search_analyzer": "hungarian_search_analyzer"},
+        "summary": {"type": "text", "analyzer": "hungarian_indexing_analyzer", "search_analyzer": "hungarian_search_analyzer"}
+    }
+}
+
+
+# --- Segédfüggvények ---
+def initialize_es_client():
+    if DEBUG_MODE: print("\nKapcsolódás az Elasticsearch-hez a GitHub Secrets adatokkal...")
+    
+    if not ES_CLOUD_ID:
+        print(f"{RED}Hiba: ES_CLOUD_ID környezeti változó hiányzik! Ezt a GitHub Secrets-ben kell beállítani.{RESET}")
+        return None
+    if not ES_API_KEY:
+        print(f"{RED}Hiba: ES_API_KEY környezeti változó hiányzik! Ezt a GitHub Secrets-ben kell beállítani.{RESET}")
+        return None
+
+    try:
+        client = Elasticsearch(
+            cloud_id=ES_CLOUD_ID,
+            api_key=ES_API_KEY,
+            request_timeout=ES_CLIENT_TIMEOUT
+        )
+        if not client.ping():
+            raise ConnectionError("Nem sikerült pingelni az Elasticsearch-t.")
+        if DEBUG_MODE: print(f"{GREEN}Sikeres Elasticsearch kapcsolat!{RESET}")
+        return client
+    except Exception as e:
+        print(f"{RED}Hiba az Elasticsearch kapcsolódás során: {e}{RESET}")
+        traceback.print_exc()
+        return None
+
+def load_embedding_model():
+    global embedding_model, EMBEDDING_DIM, device
+    if not TORCH_AVAILABLE or not SENTENCE_TRANSFORMER_AVAILABLE:
+        EMBEDDING_DIM = 768
+        device = 'cpu'
+        print(f"{RED}Hiba: PyTorch vagy SentenceTransformer nincs telepítve.{RESET}")
+        return None, EMBEDDING_DIM, device
+    
+    print(f"\n'{EMBEDDING_MODEL_NAME}' embedding modell betöltése (SentenceTransformer)...")
+    try:
+        current_device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        model = SentenceTransformer(EMBEDDING_MODEL_NAME, device=current_device)
+        print(f"ST modell betöltve, használt eszköz: {model.device}")
+        dim = model.get_sentence_embedding_dimension()
+        if not dim: raise ValueError("Nem sikerült meghatározni az embedding dimenziót.")
+        embedding_model = model
+        EMBEDDING_DIM = dim
+        device = current_device
+        # Dinamikusan frissítjük a mappinget a modell dimenziójával
+        INDEX_MAPPINGS_WEB["properties"]["embedding"]["dims"] = dim
+        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
+
+# ... A többi függvény (generate_categories_with_llm, get_embedding, create_es_index, stb.)
+# az eredeti formájában maradhat, mivel azok már helyesen működnek.
+# Itt beillesztem őket a teljesség kedvéért.
+
 def generate_categories_with_llm(llm_client, soup, text):
-    """
-    Kategóriát generál HTML menüből/címből, vagy LLM-mel, ha az előző nem sikerül.
-    """
-    # Előre definiált kategórialista, hogy az LLM mindig pontosan egyező kategóriát adjon.
     category_list = ['IT biztonsági szolgáltatások', 'szolgáltatások', 'hardver', 'szoftver', 'hírek',
                      'audiovizuális konferenciatechnika']
-
-    # 1. Keresés HTML menüpontok/útvonalak alapján (breadcrumb)
     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]
-                # Ezt a kategóriát is egyeztesse a listával
                 for cat in category_list:
                     if cat.lower() in final_category_from_html.lower():
                         print(f"{GREEN}    -> Kategória a breadcrumb alapján: '{cat}'{RESET}")
                         return [cat]
-    except Exception as e:
-        print(f"{YELLOW}    Figyelem: Hiba a breadcrumb feldolgozásakor: {e}{RESET}")
-
-    # 2. Keresés <h1> cím alapján
+    except Exception:
+        pass
     try:
         h1_tag = soup.find('h1')
         if h1_tag and h1_tag.get_text(strip=True):
@@ -146,14 +210,12 @@ def generate_categories_with_llm(llm_client, soup, text):
                 if cat.lower() in h1_text.lower():
                     print(f"{GREEN}    -> Kategória a H1 cím alapján: '{cat}'{RESET}")
                     return [cat]
-    except Exception as e:
-        print(f"{YELLOW}    Figyelem: Hiba a H1 cím feldolgozásakor: {e}{RESET}")
-
-    # 3. LLM hívás, ha semmi más nem működik
+    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, magyarázat, vagy írásjelek nélkül.
+        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:"""
@@ -166,8 +228,6 @@ Kategória:"""
                 if cat.lower() in category.lower():
                     print(f"{GREEN}    -> Kategória LLM generálás alapján: '{cat}'{RESET}")
                     return [cat]
-            print(
-                f"{YELLOW}    -> Az LLM nem talált megfelelő kategóriát a listán. 'egyéb' kategória használata.{RESET}")
             return ['egyéb']
         else:
             return ["egyéb"]
@@ -176,16 +236,11 @@ Kategória:"""
         return ['egyéb']
 
 def generate_summary_with_llm(llm_client, text):
-    """
-    Összefoglalást generál a szöveg első feléből egy LLM segítségével.
-    """
     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}
+        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:"""
-        # Csak a szöveg első 4000 tokenjét használjuk, hogy elkerüljük a token limitet
-        text_for_llm = text[:4000]
         response = llm_client.chat.completions.create(model=LLM_CHUNK_MODEL,
                                                       messages=[{"role": "user", "content": prompt}], temperature=0.5,
                                                       max_tokens=500)
@@ -193,26 +248,18 @@ Szöveg: {text}
             summary = response.choices[0].message.content.strip()
             print(f"{GREEN}    -> Sikeres LLM összefoglalás generálás.{RESET}")
             return summary
-        else:
-            return text[:300] + "..."
     except Exception as e:
         print(f"{RED}Hiba LLM összefoglaláskor: {e}{RESET}")
-        return text[:300] + "..."  # Visszaesés a manuális csonkolásra hiba esetén
+    return text[:300] + "..."
 
 def chunk_text_by_tokens(text, chunk_size, chunk_overlap):
-    """
-    Szöveg feldarabolása tokenek szerint, átfedéssel.
-    """
-    if not TIKTOKEN_AVAILABLE or not NLTK_AVAILABLE:
-        # Fallback a karakterszám alapú darabolásra, ha a tokenizáló nincs telepítve
-        print(f"{YELLOW}Figyelmeztetés: Tiktoken/NLTK hiányzik. Karakterszám alapú darabolás.{RESET}")
-        # Egyszerű karakter alapú tördelés
+    if not TIKTOKEN_AVAILABLE:
         chunks = []
         start = 0
         while start < len(text):
-            end = start + chunk_size
+            end = start + (chunk_size * 4) # Approximation
             chunks.append(text[start:end])
-            start += chunk_size - chunk_overlap
+            start = end - (chunk_overlap * 4)
         return chunks
 
     tokens = tiktoken_encoder.encode(text)
@@ -225,162 +272,27 @@ def chunk_text_by_tokens(text, chunk_size, chunk_overlap):
         start += chunk_size - chunk_overlap
     return chunks
 
-# --- Modellek és Eszközök Inicializálása ---
-# ... (ez a rész változatlan)
-def load_embedding_model():
-    global embedding_model, EMBEDDING_DIM, device
-    if not TORCH_AVAILABLE or not SENTENCE_TRANSFORMER_AVAILABLE:
-        EMBEDDING_DIM = 768
-        device = 'cpu'
-        print(f"{RED}Hiba: PyTorch vagy SentenceTransformer nincs telepítve.{RESET}")
-        return None, EMBEDDING_DIM, device
-    if embedding_model and EMBEDDING_DIM:
-        return embedding_model, EMBEDDING_DIM, device
-    print(f"\n'{EMBEDDING_MODEL_NAME}' embedding modell betöltése (SentenceTransformer)...")
-    try:
-        current_device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        model = SentenceTransformer(EMBEDDING_MODEL_NAME, device=current_device)
-        print(f"ST modell betöltve, használt eszköz: {model.device}")
-        dim = model.get_sentence_embedding_dimension()
-        if not dim: raise ValueError("Nem sikerült meghatározni az embedding dimenziót.")
-        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
-
-embedding_model, EMBEDDING_DIM, device = load_embedding_model()
-
-# === Index Beállítások & Mapping ===
-# ... (ez a rész változatlan)
-INDEX_SETTINGS_SEPARATE_ANALYZER = {
-    "analysis": {
-        "filter": {
-            "hungarian_stop": {"type": "stop", "stopwords": "_hungarian_"},
-            "hungarian_stemmer": {"type": "stemmer", "language": "hungarian"},
-            "synonym_filter": {"type": "synonym_graph", "synonyms_path": SYNONYM_FILE_PATH_IN_ES_CONFIG,
-                               "updateable": True}
-        },
-        "analyzer": {
-            "hungarian_indexing_analyzer": {"tokenizer": "standard",
-                                            "filter": ["lowercase", "hungarian_stop", "hungarian_stemmer"]},
-            "hungarian_search_analyzer": {"tokenizer": "standard",
-                                          "filter": ["lowercase", "hungarian_stop", "synonym_filter",
-                                                     "hungarian_stemmer"]}
-        }
-    }
-}
-
-INDEX_MAPPINGS_WEB = {
-    "properties": {
-        "text_content": {"type": "text", "analyzer": "hungarian_indexing_analyzer",
-                         "search_analyzer": "hungarian_search_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"},
-        "heading": {"type": "text", "analyzer": "hungarian_indexing_analyzer",
-                    "search_analyzer": "hungarian_search_analyzer"},
-        "summary": {"type": "text", "analyzer": "hungarian_indexing_analyzer",
-                    "search_analyzer": "hungarian_search_analyzer"}
-    }
-}
-
-
-# --- Segédfüggvények ---
-# <<< JAVÍTVA: A függvény most már a környezeti változókat használja
-def initialize_es_client():
-    if DEBUG_MODE: print("\nKapcsolódás az Elasticsearch-hez a GitHub Secrets adatokkal...")
-    
-    # Ellenőrizzük, hogy a szükséges környezeti változók be vannak-e állítva
-    if not ES_CLOUD_ID:
-        print(f"{RED}Hiba: ES_CLOUD_ID környezeti változó hiányzik! Ezt a GitHub Secrets-ben kell beállítani.{RESET}")
-        return None
-    if not ES_API_KEY:
-        print(f"{RED}Hiba: ES_API_KEY környezeti változó hiányzik! Ezt a GitHub Secrets-ben kell beállítani.{RESET}")
-        return None
-
-    client = None
-    try:
-        # A kliens inicializálása cloud_id és api_key segítségével
-        client = Elasticsearch(
-            cloud_id=ES_CLOUD_ID,
-            api_key=ES_API_KEY,
-            request_timeout=ES_CLIENT_TIMEOUT
-        )
-        if not client.ping():
-            raise ConnectionError("Nem sikerült pingelni az Elasticsearch-t.")
-        if DEBUG_MODE: print(f"{GREEN}Sikeres Elasticsearch kapcsolat!{RESET}")
-        return client
-    except Exception as e:
-        print(f"{RED}Hiba az Elasticsearch kapcsolódás során: {e}{RESET}")
-        traceback.print_exc()
-        return None
-
-# ... (a többi segédfüggvény változatlan)
 def get_embedding(text):
     if not embedding_model: return None
     if not text or not isinstance(text, str): return None
     try:
-        vector = embedding_model.encode(text, normalize_embeddings=True)
-        return vector.tolist()
+        return embedding_model.encode(text, normalize_embeddings=True).tolist()
     except Exception as e:
         print(f"{RED}Hiba embedding közben: {e}{RESET}")
         return None
 
-
 def create_es_index(client, index_name, index_settings, index_mappings):
-    if not EMBEDDING_DIM:
-        print(f"{RED}Hiba: Embed dim nincs.{RESET}")
-        return False
-    try:
-        embedding_mapping = index_mappings.get("properties", {}).get("embedding", {})
-        if not embedding_mapping: raise KeyError("Az 'embedding' kulcs hiányzik a mapping 'properties'-ből!")
-        if embedding_mapping.get("dims") != EMBEDDING_DIM:
-            print(f"{YELLOW}FIGYELEM: Mapping dim != Modell dim. Mapping frissítése {EMBEDDING_DIM}-re.{RESET}")
-            index_mappings["properties"]["embedding"]["dims"] = EMBEDDING_DIM
-    except KeyError as e:
-        print(f"{RED}Hiba: Mapping struktúra érvénytelen! Kulcs: {e}{RESET}")
-        return False
-    except Exception as e:
-        print(f"{RED}Hiba: Mapping hiba! {e}{RESET}")
-        return False
-    if DEBUG_MODE: print(f"\nIndex check: '{index_name}'?")
+    if DEBUG_MODE: print(f"\nIndex ellenőrzése: '{index_name}'...")
     try:
         if not client.indices.exists(index=index_name):
-            print(f"'{index_name}' létrehozása...")
-            resp = client.indices.create(index=index_name, settings=index_settings, mappings=index_mappings,
-                                         request_timeout=ES_CLIENT_TIMEOUT)
-            if resp.get('acknowledged'):
-                print(f"{GREEN}Index OK.{RESET}")
-                time.sleep(2)
-                return True
-            else:
-                print(f"{RED}Hiba: Create no ack.{RESET}")
-                return False
+            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}")
         else:
             print(f"Index '{index_name}' már létezik.")
-            return True
-    except es_exceptions.RequestError as e:
-        err_str = str(e).lower()
-        if 'resource_already_exists_exception' in err_str:
-            if DEBUG_MODE: print("Index már létezik (exception).")
-            return True
-        elif 'resource_not_found_exception' in err_str and ('synonyms_path' in err_str or (
-                SYNONYM_FILE_PATH_IN_ES_CONFIG and SYNONYM_FILE_PATH_IN_ES_CONFIG.split('/')[-1] in err_str)):
-            print(f"{RED}!!! Hiba: Szinonima fájl nincs ES-ben: '{SYNONYM_FILE_PATH_IN_ES_CONFIG}'?{RESET}")
-        else:
-            print(f"{RED}!!! Hiba index create (RequestError): {e}{RESET}")
-        return False
+        return True
     except Exception as e:
-        print(f"{RED}!!! Hiba index check/create: {e}{RESET}")
+        print(f"{RED}!!! Hiba az index létrehozásakor: {e}{RESET}")
         traceback.print_exc()
         return False
 
@@ -392,224 +304,135 @@ def extract_text_from_html(html_content):
         main_content = soup.find('main') or soup.find('article') or soup.body
         if main_content:
             text = main_content.get_text(separator='\n', strip=True)
-            cleaned_text = "\n".join(line for line in text.splitlines() if line.strip())
-            return cleaned_text
-        else:
-            return ""
+            return "\n".join(line for line in text.splitlines() if line.strip())
     except Exception as e:
-        print(f"{RED}Hiba HTML elemzés: {e}{RESET}")
-        return ""
-
+        print(f"{RED}Hiba a HTML tartalom kinyerésekor: {e}{RESET}")
+    return ""
 
 def extract_and_filter_links(soup, base_url, target_domain):
     links = set()
-    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:
-                    normalized_url = parsed_url._replace(fragment="").geturl()
-                    links.add(normalized_url)
-    except Exception as e:
-        print(f"{RED}Hiba link kinyerés: {e}{RESET}")
+    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())
     return links
 
 def crawl_and_index_website(start_url, max_depth, es_client, index_name):
-    if not es_client: print(f"{RED}Hiba: ES kliens nincs init.{RESET}"); return 0
-    if not embedding_model: print(f"{RED}Hiba: Embedding modell nincs init.{RESET}"); return 0
-    try:
-        import requests;
-        from bs4 import BeautifulSoup;
-        from urllib.parse import urljoin, \
-            urlparse;
-        from collections import deque
-    except ImportError:
-        print(f"{RED}Hiba: Crawling könyvtárak hiányoznak.{RESET}");
-        return 0
-
-    global together_client, BATCH_SIZE, CHUNK_SIZE_TOKENS, CHUNK_OVERLAP_TOKENS, MIN_CHUNK_SIZE_CHARS
-
     visited_urls = set()
     urls_to_visit = deque([(start_url, 0)])
     bulk_actions = []
-    total_prepared = 0;
     total_indexed = 0
-    try:
-        target_domain = urlparse(start_url).netloc;
-    except Exception as url_err:
-        print(f"{RED}Hiba: Start URL feldolgozása ({start_url}): {url_err}{RESET}");
-        return 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
+        current_url, current_depth = urls_to_visit.popleft()
+        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:
-            current_url, current_depth = urls_to_visit.popleft()
-            try:
-                parsed_check = urlparse(current_url);
-            except Exception as parse_err:
-                print(f"  {YELLOW}-> Hibás URL formátum, kihagyva: {current_url}{RESET}");
-                continue
-            if current_url in visited_urls: continue
-            if current_depth > max_depth: continue
-            print(f"\n--- Feldolgozás (Mélység: {current_depth}): {current_url} ---")
-            visited_urls.add(current_url)
-            html_content = None
-            try:
-                headers = {'User-Agent': USER_AGENT}
-                response = requests.get(current_url, headers=headers, timeout=15)
-                response.raise_for_status()
-                content_type = response.headers.get('content-type', '').lower()
-                if 'text/html' not in content_type: print(
-                    f"  {YELLOW}-> Nem HTML ({content_type}), kihagyva.{RESET}"); continue
-                html_content = response.content
-            except requests.exceptions.RequestException as req_err:
-                print(f"  {RED}!!! Hiba letöltés: {req_err}{RESET}");
+            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
-            except Exception as fetch_err:
-                print(f"  {RED}!!! Váratlan hiba letöltés: {fetch_err}{RESET}");
-                continue
-
-            if DEBUG_MODE: print("  HTML elemzése és kategorizálása...")
+            
+            html_content = response.content
             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}");
+                print(f"  {YELLOW}-> Nem sikerült szöveget kinyerni vagy túl rövid.{RESET}")
                 continue
-
-            # --- ÚJ, JAVÍTOTT LOGIKA ---
-            # 1. Szövegtördelés token alapján
+            
             final_chunks = chunk_text_by_tokens(page_text, CHUNK_SIZE_TOKENS, CHUNK_OVERLAP_TOKENS)
-            chunk_type = "token_chunking"
-
-            # 2. LLM-alapú kategorizálás (az első 1000 karakter alapján)
-            url_category = generate_categories_with_llm(together_client, soup, page_text[:1000])[0]
-
-            # 3. LLM-alapú összefoglalás a teljes oldalhoz, ha van LLM kliens
+            url_category = generate_categories_with_llm(together_client, soup, page_text)[0]
             page_summary = generate_summary_with_llm(together_client, page_text)
-
-            # --- INDEXELÉS ELŐKÉSZÍTÉSE ---
-            if final_chunks:
-                print(
-                    f"{GREEN}    Indexelendő chunkok: {len(final_chunks)} (Típus: {chunk_type}, Kategória: {url_category}){RESET}")
-            else:
-                print(f"{RED}    Nincs indexelendő chunk ({chunk_type}).{RESET}");
-                continue
-
-            if DEBUG_MODE: print(f"  Chunkok indexelésének előkészítése...")
-            page_chunk_count = 0
+            
+            print(f"{GREEN}    Indexelésre előkészítve: {len(final_chunks)} darab (Kategória: {url_category}){RESET}")
+            
             for chunk_text in final_chunks:
                 element_vector = get_embedding(chunk_text)
                 if element_vector:
-                    total_prepared += 1;
-                    page_chunk_count += 1
-                    doc = {"text_content": chunk_text, "embedding": element_vector, "source_origin": "website",
-                           "source_url": current_url, "source_type": chunk_type, "category": url_category,
-                           "summary": page_summary}
+                    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:
-                        if DEBUG_MODE: print(f"    -> {len(bulk_actions)} web chunk indexelése (batch)...")
-                        try:
-                            success_count, errors = helpers.bulk(es_client, bulk_actions, raise_on_error=False,
-                                                                 request_timeout=ES_CLIENT_TIMEOUT)
-                            total_indexed += success_count
-                            if errors: print(f"{RED}!!! Hiba web bulk: {len(errors)} sikertelen.{RESET}")
-                        except Exception as be:
-                            print(f"{RED}!!! Váratlan web bulk hiba: {be}{RESET}")
-                        finally:
-                            bulk_actions = []
-            print(f"    Oldal ({current_url}) feldolgozása kész ({page_chunk_count} chunk indexelve).")
+            
+            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 current_depth < max_depth:
-                if DEBUG_MODE: print("  Linkek keresése...")
-                try:
-                    soup_for_links = BeautifulSoup(html_content, 'html.parser')
-                    new_links = extract_and_filter_links(soup_for_links, current_url, target_domain)
-                    if DEBUG_MODE: print(f"    Talált {len(new_links)} új, belső linket.")
-                    for link in new_links:
-                        if link not in visited_urls:
-                            if len(urls_to_visit) < 5000:
-                                urls_to_visit.append((link, current_depth + 1))
-                            else:
-                                print(
-                                    f"{YELLOW}Figyelmeztetés: A bejárási sor túl hosszú, új link kihagyva: {link}{RESET}")
-                except Exception as link_err:
-                    print(f"{RED}!!! Hiba linkek kinyerése: {link_err}{RESET}")
-            if DEBUG_MODE: print(f"    Várakozás {REQUEST_DELAY} mp..."); time.sleep(REQUEST_DELAY)
-        except KeyboardInterrupt:
-            print("\nFolyamat megszakítva.");
-            break
-        except Exception as loop_err:
-            print(f"{RED}!!! Hiba ciklusban ({current_url}): {loop_err}{RESET}");
-            traceback.print_exc();
-            time.sleep(5)
+                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}")
+            traceback.print_exc()
 
     if bulk_actions:
-        if DEBUG_MODE: print(f"    -> Maradék {len(bulk_actions)} web chunk indexelése...")
-        try:
-            success_count, errors = helpers.bulk(es_client, bulk_actions, raise_on_error=False,
-                                                 request_timeout=ES_CLIENT_TIMEOUT)
-            total_indexed += success_count
-            if errors: print(f"{RED}!!! Hiba maradék web bulk: {len(errors)} sikertelen.{RESET}")
-        except Exception as be:
-            print(f"{RED}!!! Maradék web bulk hiba: {be}{RESET}")
+        print(f"    -> Maradék {len(bulk_actions)} chunk indexelése...")
+        success_count, _ = helpers.bulk(es_client, bulk_actions)
+        total_indexed += success_count
 
     print(f"\n--- Web Crawling és Indexelés Befejezve ---")
     print(f"Meglátogatott URL-ek: {len(visited_urls)}")
-    print(f"Előkészített chunk: {total_prepared}")
-    final_success = min(total_indexed, total_prepared)
-    print(f"Sikeresen indexelt chunk: {final_success}")
-    return final_success
+    print(f"Sikeresen indexelt chunkok: {total_indexed}")
+    return total_indexed
 
-# ... (a main függvény változatlan)
 if __name__ == "__main__":
-    print(f"----- Web Crawler és Indexelő Indítása a '{VECTOR_INDEX_NAME}' indexbe (LLM-alapú) -----")
-    print(f"----- Cél URL: {START_URL} (Max mélység: {MAX_DEPTH}) -----")
-    print("****** FIGYELEM ******")
-    print(f"Ez a script létrehozza/használja a '{VECTOR_INDEX_NAME}' indexet.")
-    print(f"Győződj meg róla, hogy a szinonima beállítások az ES-ben léteznek ehhez az indexhez.")
-    print(f"{RED}Ha a '{VECTOR_INDEX_NAME}' index már létezik, TÖRÖLD manuálisan futtatás előtt!{RESET}")
-    print("SZÜKSÉGES KÖNYVTÁRAK: requests, beautifulsoup4, nltk, tiktoken, together stb.")
-    print("******------------******")
-
-    if not TORCH_AVAILABLE: print(f"{RED}Hiba: PyTorch.{RESET}"); exit(1)
-    if not SENTENCE_TRANSFORMER_AVAILABLE: print(f"{RED}Hiba: SentenceTransformer.{RESET}"); exit(1)
-    if not embedding_model: print(f"{RED}Hiba: Embedding modell.{RESET}"); exit(1)
-    if not EMBEDDING_DIM: print(f"{RED}Hiba: Embedding dim.{RESET}"); exit(1)
-    try:
-        import requests;
-        from bs4 import BeautifulSoup;
-        from urllib.parse import urljoin, \
-            urlparse;
-        from collections import deque
-    except ImportError:
-        print(f"{RED}Hiba: Crawling könyvtárak.{RESET}");
+    print(f"----- Web Crawler és Indexelő Indítása -----")
+    
+    embedding_model, EMBEDDING_DIM, device = load_embedding_model()
+    
+    if not all([embedding_model, EMBEDDING_DIM]):
+        print(f"{RED}Hiba: Az embedding modell betöltése sikertelen. A program leáll.{RESET}")
         exit(1)
 
     es_client = initialize_es_client()
-    final_success_count = 0
-    index_ready = False
     if es_client:
-        index_ready = create_es_index(client=es_client, index_name=VECTOR_INDEX_NAME,
-                                      index_settings=INDEX_SETTINGS_SEPARATE_ANALYZER,
-                                      index_mappings=INDEX_MAPPINGS_WEB)
+        if es_client.indices.exists(index=VECTOR_INDEX_NAME):
+            print(f"{YELLOW}Figyelem: A '{VECTOR_INDEX_NAME}' index már létezik. A script feltételezi, hogy a beállításai helyesek.{RESET}")
+            print(f"{YELLOW}Ha újra akarod építeni, töröld manuálisan: DELETE /{VECTOR_INDEX_NAME}{RESET}")
+            index_ready = True
+        else:
+            index_ready = create_es_index(
+                client=es_client, 
+                index_name=VECTOR_INDEX_NAME,
+                index_settings=INDEX_SETTINGS_SEPARATE_ANALYZER,
+                index_mappings=INDEX_MAPPINGS_WEB
+            )
+        
         if index_ready:
             print(f"\nIndex '{VECTOR_INDEX_NAME}' kész. Web crawling és indexelés indítása...")
             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: Index nem áll készen.{RESET}")
-    else:
-        print(f"{RED}Hiba: ES kliens nem elérhető.{RESET}")
-    print("\n----- Feldolgozás Befejezve -----")
-    if index_ready and final_success_count > 0:
-        print(
-            f"\n{GREEN}Crawling és indexelés sikeres. {final_success_count} chunk indexelve '{VECTOR_INDEX_NAME}'-be.{RESET}");
-        print(f"Ellenőrzés: GET /{VECTOR_INDEX_NAME}/_count");
-        print(f"\nFontos: A RAG scriptet módosítani kell, hogy '{VECTOR_INDEX_NAME}' indexben IS keressen.")
-    elif index_ready and final_success_count == 0:
-        print(f"{YELLOW}Crawling lefutott, de 0 chunk indexelve.{RESET}")
-    elif not index_ready:
-        print(f"{RED}Index nem jött létre.{RESET}")
+            print(f"{RED}Hiba: Az index nem áll készen a használatra. A program leáll.{RESET}")
     else:
-        print(f"{RED}Folyamat hibával zárult.{RESET}")
+        print(f"{RED}Hiba: Az Elasticsearch kliens nem elérhető. A program leáll.{RESET}")