Fix: Clean up requirements.txt to resolve build conflicts

web_indexer_universal_v7.py

@@ -1,5 +1,5 @@
 # web_indexer_universal_v7.py
-# VÉGLEGES, JAVÍTOTT VERZIÓ
+# VÉGLEGES VERZIÓ 2.0: Szinonimák nélkül, dinamikus AI kategorizálással.
 
 import os
 import time
@@ -24,7 +24,6 @@ try:
     TORCH_AVAILABLE = True
 except ImportError:
     TORCH_AVAILABLE = False
-    print(f"{RED}FIGYELEM: Torch nincs telepítve.{RESET}")
 
 try:
     import together
@@ -85,44 +84,35 @@ CHUNK_OVERLAP_TOKENS = 50
 MIN_CHUNK_SIZE_CHARS = 50
 LLM_CHUNK_MODEL = "mistralai/Mixtral-8x7B-Instruct-v0.1"
 
-# === Index Beállítások & Mapping (JAVÍTOTT VERZIÓ) ===
-INDEX_SETTINGS_SEPARATE_ANALYZER = {
+# === Index Beállítások & Mapping (EGYSZERŰSÍTETT, SZINONIMÁK NÉLKÜL) ===
+INDEX_SETTINGS_SIMPLE = {
     "analysis": {
         "filter": {
             "hungarian_stop": {"type": "stop", "stopwords": "_hungarian_"},
-            "hungarian_stemmer": {"type": "stemmer", "language": "hungarian"},
-            "synonym_filter": {
-                "type": "synonym_graph",
-                "synonyms_set": "synonyms-hu"
-            }
+            "hungarian_stemmer": {"type": "stemmer", "language": "hungarian"}
         },
         "analyzer": {
-            "hungarian_indexing_analyzer": {
+            "hungarian_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 = {
+INDEX_MAPPINGS_SIMPLE = {
     "properties": {
-        "text_content": {"type": "text", "analyzer": "hungarian_indexing_analyzer", "search_analyzer": "hungarian_search_analyzer"},
+        "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"},
-        "heading": {"type": "text", "analyzer": "hungarian_indexing_analyzer", "search_analyzer": "hungarian_search_analyzer"},
-        "summary": {"type": "text", "analyzer": "hungarian_indexing_analyzer", "search_analyzer": "hungarian_search_analyzer"}
+        "category": {"type": "keyword"}, # A 'keyword' típus listákat is tud kezelni
+        "heading": {"type": "text", "analyzer": "hungarian_analyzer"},
+        "summary": {"type": "text", "analyzer": "hungarian_analyzer"}
     }
 }
 
-
 # --- Segédfüggvények ---
 def initialize_es_client():
     print(f"\n{CYAN}Kapcsolódás az Elasticsearch-hez...{RESET}")
@@ -135,8 +125,7 @@ def initialize_es_client():
             api_key=ES_API_KEY,
             request_timeout=ES_CLIENT_TIMEOUT
         )
-        if not client.ping():
-            raise ConnectionError("Ping sikertelen.")
+        if not client.ping(): raise ConnectionError("Ping sikertelen.")
         print(f"{GREEN}Sikeres Elasticsearch kapcsolat!{RESET}")
         return client
     except Exception as e:
@@ -155,13 +144,83 @@ def load_embedding_model():
         model = SentenceTransformer(EMBEDDING_MODEL_NAME, device=device)
         embedding_model = model
         EMBEDDING_DIM = model.get_sentence_embedding_dimension()
-        INDEX_MAPPINGS_WEB["properties"]["embedding"]["dims"] = EMBEDDING_DIM
+        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):
+    # Ez a függvény változatlan
+    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):
+    # Ez a függvény változatlan
+    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
+
 def get_embedding(text):
+    # Ez a függvény változatlan
     if not embedding_model: return None
     try:
         return embedding_model.encode(text, normalize_embeddings=True).tolist()
@@ -169,7 +228,23 @@ def get_embedding(text):
         print(f"{RED}Hiba embedding közben: {e}{RESET}")
         return None
 
+def create_es_index(client, index_name, index_settings, index_mappings):
+    # Ez a függvény változatlan
+    print(f"\n{CYAN}Index ellenőrzése: '{index_name}'...{RESET}")
+    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}")
+        else:
+            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}")
+        return False
+
 def extract_text_from_html(html_content):
+    # Ez a függvény változatlan
     try:
         soup = BeautifulSoup(html_content, 'html.parser')
         for element in soup(["script", "style", "nav", "footer", "header", "aside", "form"]):
@@ -179,22 +254,29 @@ def extract_text_from_html(html_content):
         return "\n".join(line for line in text.splitlines() if line.strip())
     except Exception as e:
         print(f"{RED}Hiba a HTML tartalom kinyerésekor: {e}{RESET}")
-        return ""
+    return ""
+
+def extract_and_filter_links(soup, base_url, target_domain):
+    # Ez a függvény változatlan
+    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())
+    return links
 
 def crawl_and_index_website(start_url, max_depth, es_client, index_name):
-    # Itt folytatódik a weboldal bejárásáért és indexeléséért felelős,
-    # hosszú `crawl_and_index_website` függvény, ahogy korábban is volt.
-    # A teljesség kedvéért ide másolom a korábban megadott kódodat.
-    visited_urls = set()
-    urls_to_visit = deque([(start_url, 0)])
-    bulk_actions = []
-    total_indexed = 0
+    visited_urls, urls_to_visit = set(), deque([(start_url, 0)])
+    bulk_actions, total_indexed = [], 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, current_depth = urls_to_visit.popleft()
-        if current_url in visited_urls or current_depth > max_depth:
+        if current_url in visited_urls:
             continue
         
         print(f"\n--- Feldolgozás (Mélység: {current_depth}): {current_url} ---")
@@ -216,27 +298,20 @@ def crawl_and_index_website(start_url, max_depth, es_client, index_name):
                 print(f"  {YELLOW}-> Nem sikerült szöveget kinyerni vagy túl rövid.{RESET}")
                 continue
             
-            # A chunking, category, summary generálás függvények a korábbiak szerint
-            # ... feltételezve, hogy azok léteznek és működnek ...
-            final_chunks = [page_text] # Egyszerűsített példa, a te chunking logikád ide kerül
-            url_category = "általános"  # Egyszerűsített példa
-            page_summary = page_text[:200] + "..." # Egyszerűsített példa
+            final_chunks = chunk_text_by_tokens(page_text, CHUNK_SIZE_TOKENS, CHUNK_OVERLAP_TOKENS)
+            # JAVÍTVA: Az új, dinamikus kategória generáló függvény hívása
+            categories = generate_dynamic_categories_with_llm(together_client, soup, page_text)
+            page_summary = generate_summary_with_llm(together_client, page_text)
             
-            print(f"{GREEN}    Indexelésre előkészítve: {len(final_chunks)} darab (Kategória: {url_category}){RESET}")
+            print(f"{GREEN}    Indexelésre előkészítve: {len(final_chunks)} darab (Kategóriák: {categories}){RESET}")
             
-            page_chunk_count = 0
             for chunk_text in final_chunks:
                 element_vector = get_embedding(chunk_text)
                 if element_vector:
-                    page_chunk_count += 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
+                        "text_content": chunk_text, "embedding": element_vector, "source_origin": "website",
+                        "source_url": current_url, "source_type": "token_chunking", 
+                        "category": categories, "summary": page_summary
                     }
                     bulk_actions.append({"_index": index_name, "_source": doc})
             
@@ -246,18 +321,11 @@ def crawl_and_index_website(start_url, max_depth, es_client, index_name):
                 total_indexed += success_count
                 bulk_actions = []
 
-            print(f"    Oldal feldolgozva, {page_chunk_count} chunk hozzáadva a kötegelt feltöltéshez.")
-
             if current_depth < max_depth:
-                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:
-                            link = parsed_url._replace(fragment="").geturl()
-                            if link not in visited_urls:
-                                urls_to_visit.append((link, current_depth + 1))
+                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)
 
@@ -278,7 +346,7 @@ def crawl_and_index_website(start_url, max_depth, es_client, index_name):
 
 # === Fő Program ===
 if __name__ == "__main__":
-    print("----- Web Crawler és Indexelő Indítása -----")
+    print("----- Web Crawler és Indexelő Indítása (Dinamikus AI Kategorizálással) -----")
     
     load_embedding_model()
     
@@ -290,31 +358,27 @@ if __name__ == "__main__":
 
     if es_client:
         try:
-            # Tiszta kezdés: töröljük a régi indexet, ha létezik
             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 létrehozása a javított beállításokkal
-            print(f"'{VECTOR_INDEX_NAME}' index létrehozása a javított beállításokkal...")
-            es_client.indices.create(
-                index=VECTOR_INDEX_NAME, 
-                settings=INDEX_SETTINGS_SEPARATE_ANALYZER, 
-                mappings=INDEX_MAPPINGS_WEB
+            index_ready = create_es_index(
+                client=es_client, 
+                index_name=VECTOR_INDEX_NAME,
+                index_settings=INDEX_SETTINGS_SIMPLE,
+                index_mappings=INDEX_MAPPINGS_SIMPLE
             )
-            print(f"{GREEN}Index sikeresen létrehozva.{RESET}")
-
-            # 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}")
+            
+            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"\n{YELLOW}A folyamat lefutott, de 0 új dokumentum került indexelésre.{RESET}")
-
+                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}")
-            traceback.print_exc()
     else:
-        print(f"{RED}Hiba: Az Elasticsearch kliens nem elérhető. A program leáll.{RESET}")
+        print(f"{RED}Hiba: Az Elasticsearch kliens nem elérhető.{RESET}")