Fix: Clean up requirements.txt to resolve build conflicts

appv1.py

@@ -1,42 +1,58 @@
 # appv1.py
 # A RAG rendszer grafikus felhasználói felülete Streamlit segítségével.
-# Végleges verzió, Chat és Admin felülettel.
-# Igazítva a backendv1.py-hoz.
-# Kiegészítve a legjobb találati pontszám megjelenítésével.
+# JAVÍTOTT VERZIÓ: A modern, cloud-kompatibilis backendv1.py-hoz igazítva.
 
 import streamlit as st
 import sys
 import os
 
-# A backendv1.py importálása, a futtatható könyvtárhoz hozzáadása.
-# Feltételezi, hogy a backendv1.py és az appv1.py ugyanabban a mappában van.
-sys.path.append(os.path.dirname(__file__))
-
-# Az összes szükséges függvény importálása a backendből
-from backendv1 import (
-    initialize_backend,
-    process_query,
-    index_feedback,
-    get_all_feedback,
-    delete_feedback_by_id,
-    update_feedback_comment,
-    CONFIG
-)
+# --- Backend Importálása ---
+# A backendv1.py-nak ebben a mappában kell lennie.
+try:
+    from backendv1 import (
+        initialize_backend,
+        process_query,
+        index_feedback,
+        get_all_feedback,
+        delete_feedback_by_id,
+        update_feedback_comment,
+        CONFIG
+    )
+except ImportError:
+    st.error("Hiba: A 'backendv1.py' fájl nem található. Győződj meg róla, hogy ugyanabban a mappában van, mint ez a script.")
+    st.stop()
 
 # --- Oldal Konfiguráció ---
 st.set_page_config(page_title="Dunaelektronika AI", layout="wide")
 st.title("🤖 Dunaelektronika AI Asszisztens")
 
 
-# --- Backend Betöltése (gyorsítótárazva) ---
+# --- Backend Betöltése (gyorsítótárazva, hogy ne töltődjön be minden interakciónál újra) ---
 @st.cache_resource
 def load_backend_components():
-    return initialize_backend()
-
+    """
+    Betölti a backendet (AI modellek, DB kapcsolat).
+    A @st.cache_resource biztosítja, hogy ez a lassú folyamat csak egyszer fusson le.
+    """
+    print("Backend komponensek inicializálása...")
+    backend_data = initialize_backend()
+    if backend_data:
+        print("Backend sikeresen betöltve.")
+    else:
+        print("Hiba a backend betöltésekor.")
+    return backend_data
 
+# Backend betöltése és hibakezelés
 backend = load_backend_components()
+if not backend:
+    st.error(
+        "A háttérrendszer (AI modellek vagy adatbázis kapcsolat) nem tudott elindulni. "
+        "Ellenőrizd a konzol logját a hiba okáért, és hogy a környezeti változók (pl. .env fájl) helyesen vannak-e beállítva."
+    )
+    st.stop()
 
-# --- Session State Inicializálása ---
+
+# --- Session State Inicializálása (az adatok tárolására a böngészőben) ---
 if "messages" not in st.session_state:
     st.session_state.messages = []
 if "last_confidence_score" not in st.session_state:
@@ -47,15 +63,12 @@ if "page" not in st.session_state:
 # --- Navigáció az Oldalsávon ---
 with st.sidebar:
     st.header("Menü")
-    if st.button("💬 Chat", use_container_width=True,
-                 type="primary" if st.session_state.page == "Chat" else "secondary"):
+    if st.button("💬 Chat", use_container_width=True, type="primary" if st.session_state.page == "Chat" else "secondary"):
         st.session_state.page = "Chat"
         st.rerun()
-    if st.button("⚙️ Feedback Adminisztráció", use_container_width=True,
-                 type="primary" if st.session_state.page == "Admin" else "secondary"):
+    if st.button("⚙️ Feedback Adminisztráció", use_container_width=True, type="primary" if st.session_state.page == "Admin" else "secondary"):
         st.session_state.page = "Admin"
         st.rerun()
-
     st.write("---")
 
 # ==============================================================================
@@ -64,17 +77,14 @@ with st.sidebar:
 if st.session_state.page == "Chat":
     with st.sidebar:
         st.header("Beállítások")
-        # A 0.1 egy jó alapértelmezett érték, de a pontos tartomány a Cross-Encoder modell kimenetétől függ
-        confidence_threshold = st.slider("Minimális pontossági küszöb", min_value=-5.0, max_value=5.0, value=0.1,
-                                         step=0.1)
-        fallback_message = st.text_area("Válasz alacsony pontosságnál",
-                                        "A rendelkezésre álló információk alapján sajnos nem tudok egyértelmű választ adni a kérdésre.",
-                                        height=100)
+        confidence_threshold = st.slider("Minimális pontossági küszöb", min_value=-5.0, max_value=5.0, value=0.1, step=0.1)
+        fallback_message = st.text_area("Válasz alacsony pontosságnál", "A rendelkezésre álló információk alapján sajnos nem tudok egyértelmű választ adni a kérdésre.", height=100)
         CONFIG["GENERATION_TEMPERATURE"] = st.slider("Kreativitás (Temperature)", 0.0, 1.0, 0.6, 0.05)
 
         st.write("---")
         st.subheader("Utolsó Válasz Elemzése")
         score = st.session_state.last_confidence_score
+        
         if score == "N/A":
             level, help_text = "N/A", "Tegyen fel egy kérdést a megbízhatóság méréséhez."
         elif score is None:
@@ -83,12 +93,9 @@ if st.session_state.page == "Chat":
             level, help_text = "Kurált Válasz", "Ez egy korábban megadott, pontosított válasz."
         else:
             help_text = f"Nyers pontszám: {score:.4f}"
-            if score > 1.0:
-                level = "Magas"
-            elif score >= -1.5:
-                level = "Közepes"
-            else:
-                level = "Alacsony"
+            if score > 1.0: level = "Magas"
+            elif score >= -1.5: level = "Közepes"
+            else: level = "Alacsony"
         st.metric(label="Keresési Magabiztosság", value=level, help=help_text)
 
     # Chat Előzmények Megjelenítése
@@ -96,72 +103,53 @@ if st.session_state.page == "Chat":
         with st.chat_message(message["role"]):
             st.markdown(message["content"].replace('$', '\\$'))
             if message["role"] == "assistant":
-                # --- HOZZÁADOTT RÉSZ ---
-                # A válaszhoz tartozó pontszám megjelenítése, ha létezik.
                 score_value = message.get("score")
                 if score_value is not None:
-                    if score_value == 10.0:
-                        score_display = "Kurált válasz (legmagasabb)"
-                    else:
-                        score_display = f"{score_value:.4f}"
+                    score_display = "Kurált válasz (legmagasabb)" if score_value == 10.0 else f"{score_value:.4f}"
                     st.caption(f"A válasz legjobb score értéke: **{score_display}**")
-                # --- HOZZÁADOTT RÉSZ VÉGE ---
-
+                
                 if message.get("sources"):
                     with st.expander("Felhasznált források"):
                         for source in message["sources"]:
                             st.caption(f"Forrás: {source.get('url', 'N/A')}")
                             st.markdown(f"> {source.get('content', '')[:250]}...")
-
+                
                 feedback_key_prefix = f"feedback_{i}"
                 if not message.get("rated"):
                     st.write("---")
                     cols = st.columns(7)
                     if cols[0].button("👍 Jó", key=f"{feedback_key_prefix}_good"):
-                        message["rated"] = "good";
-                        st.toast("Köszönjük a visszajelzést!");
-                        st.rerun()
+                        message["rated"] = "good"; st.toast("Köszönjük a visszajelzést!"); st.rerun()
                     if cols[1].button("👎 Rossz", key=f"{feedback_key_prefix}_bad"):
-                        message["rated"] = "bad";
-                        st.rerun()
+                        message["rated"] = "bad"; st.rerun()
 
                 if message.get("rated") == "bad":
                     with st.form(key=f"{feedback_key_prefix}_form"):
-                        correction_text = st.text_area("Javítás:", key=f"{feedback_key_prefix}_text",
-                                                       value=message.get("correction", ""))
+                        correction_text = st.text_area("Javítás:", key=f"{feedback_key_prefix}_text", value=message.get("correction", ""))
                         if st.form_submit_button("Javítás elküldése"):
-                            # Hívás a backendv1 függvényre
-                            index_feedback(backend["es_client"], backend["embedding_model"],
-                                           message["original_question"], correction_text)
-                            st.success("Javításodat rögzítettük!");
-                            message["rated"] = "corrected";
-                            st.rerun()
+                            index_feedback(backend["es_client"], backend["embedding_model"], message["original_question"], correction_text)
+                            st.success("Javításodat rögzítettük!"); message["rated"] = "corrected"; st.rerun()
 
     # Felhasználói Kérdés Feldolgozása
     if prompt := st.chat_input("Kérdezz valamit a Dunaelektronikáról..."):
         st.session_state.messages.append({"role": "user", "content": prompt})
         with st.spinner("Keresek és gondolkodom..."):
-            # Hívás a backendv1 függvényre
-            response_data = process_query(prompt, st.session_state.messages, backend, confidence_threshold,
-                                          fallback_message)
+            response_data = process_query(prompt, st.session_state.messages, backend, confidence_threshold, fallback_message)
 
         st.session_state.last_confidence_score = response_data.get("confidence_score")
-
-        # --- MÓDOSÍTOTT RÉSZ ---
-        # A válasz üzenethez hozzáadjuk a 'score' kulcsot is, hogy később meg tudjuk jeleníteni.
+        
         st.session_state.messages.append({
             "role": "assistant",
             "content": response_data.get("answer", "Hiba történt."),
             "sources": response_data.get("sources", []),
             "original_question": prompt,
             "rated": False,
-            "score": response_data.get("confidence_score")  # Itt adjuk hozzá a pontszámot
+            "score": response_data.get("confidence_score")
         })
-        # --- MÓDOSÍTOTT RÉSZ VÉGE ---
         st.rerun()
 
 # ==============================================================================
-# =                           ADMIN OLDAL LOGIKÁJA                             =
+# =                            ADMIN OLDAL LOGIKÁJA                            =
 # ==============================================================================
 elif st.session_state.page == "Admin":
     st.header("Rögzített Visszajelzések Kezelése")
@@ -169,52 +157,32 @@ elif st.session_state.page == "Admin":
     if st.button("Lista frissítése"):
         st.cache_data.clear()
 
-
     @st.cache_data(ttl=60)
     def get_cached_feedback():
-        # Hívás a backendv1 függvényre
         return get_all_feedback(backend["es_client"], CONFIG["FEEDBACK_INDEX_NAME"])
 
-
     feedback_list = get_cached_feedback()
 
     if not feedback_list:
         st.warning("Nincsenek rögzített visszajelzések.")
     else:
         st.info(f"Összesen {len(feedback_list)} visszajelzés található.")
-
         for item in feedback_list:
             doc_id = item["_id"]
             source = item["_source"]
-
             with st.container(border=True):
                 st.markdown(f"**Kérdés:** `{source.get('question_text', 'N/A')}`")
-
                 with st.form(key=f"edit_form_{doc_id}"):
-                    new_comment = st.text_area("Javítás/Megjegyzés:", value=source.get('correction_text', ''),
-                                               key=f"text_{doc_id}", label_visibility="collapsed")
-
+                    new_comment = st.text_area("Javítás/Megjegyzés:", value=source.get('correction_text', ''), key=f"text_{doc_id}", label_visibility="collapsed")
                     col1, col2 = st.columns([4, 1])
-
                     with col1:
                         if st.form_submit_button("💾 Mentés"):
-                            # Hívás a backendv1 függvényre
-                            if update_feedback_comment(backend["es_client"], CONFIG["FEEDBACK_INDEX_NAME"], doc_id,
-                                                       new_comment):
-                                st.success("Sikeresen frissítve!")
-                                st.cache_data.clear()
-                                st.rerun()
-                            else:
-                                st.error("Hiba történt a frissítés során.")
-
+                            if update_feedback_comment(backend["es_client"], CONFIG["FEEDBACK_INDEX_NAME"], doc_id, new_comment):
+                                st.success("Sikeresen frissítve!"); st.cache_data.clear(); st.rerun()
+                            else: st.error("Hiba történt a frissítés során.")
                     with col2:
                         if st.form_submit_button("🗑️ Törlés"):
-                            # Hívás a backendv1 függvényre
                             if delete_feedback_by_id(backend["es_client"], CONFIG["FEEDBACK_INDEX_NAME"], doc_id):
-                                st.success(f"Sikeresen törölve!")
-                                st.cache_data.clear()
-                                st.rerun()
-                            else:
-                                st.error("Hiba történt a törlés során.")
-
-                st.caption(f"Elasticsearch ID: {doc_id} | Időbélyeg: {source.get('timestamp', 'N/A')}")
+                                st.success(f"Sikeresen törölve!"); st.cache_data.clear(); st.rerun()
+                            else: st.error("Hiba történt a törlés során.")
+                st.caption(f"Elasticsearch ID: {doc_id} | Időbélyeg: {source.get('timestamp', 'N/A')}")

backendv1.py

@@ -1,6 +1,6 @@
 # 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.
-# Végleges, refaktorált verzió. Gyors, egylépcsős generálással.
 
 import os
 import time
@@ -8,18 +8,23 @@ import datetime
 import json
 import re
 from collections import defaultdict
-from together import Together
 from elasticsearch import Elasticsearch, exceptions as es_exceptions
 import torch
 from sentence_transformers import SentenceTransformer
 from sentence_transformers.cross_encoder import CrossEncoder
 from spellchecker import SpellChecker
-import warnings
 from dotenv import load_dotenv
 import sys
 import nltk
 from concurrent.futures import ThreadPoolExecutor
 
+# Késleltetett importálás, hogy csak akkor legyen hiba, ha tényleg használjuk
+try:
+    from together import Together
+    TOGETHER_AVAILABLE = True
+except ImportError:
+    TOGETHER_AVAILABLE = False
+
 # === ANSI Színkódok (konzol loggoláshoz) ===
 GREEN = '\033[92m'
 YELLOW = '\033[93m'
@@ -30,9 +35,8 @@ 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.
 CONFIG = {
-    "ELASTIC_PASSWORD": os.environ.get("ES_PASSWORD", "T8xEbqQ4GAPkr73s2knN"),
-    "ELASTIC_HOST": "https://localhost:9200",
     "VECTOR_INDEX_NAMES": ["duna", "dunawebindexai"],
     "FEEDBACK_INDEX_NAME": "feedback_index",
     "ES_CLIENT_TIMEOUT": 90,
@@ -49,134 +53,81 @@ CONFIG = {
     "MAX_GENERATION_TOKENS": 1024,
     "GENERATION_TEMPERATURE": 0.6,
     "USE_QUERY_EXPANSION": True,
-    "SPELLCHECK_LANG": 'hu',
-    "MAX_HISTORY_TURNS": 3,
-    "HUNGARIAN_STOP_WORDS": set(
-        ["a", "az", "egy", "és", "hogy", "ha", "is", "itt", "ki", "mi", "mit", "mikor", "hol", "hogyan", "nem", "ne",
-         "de", "csak", "meg", "megint", "már", "mint", "még", "vagy", "valamint", "van", "volt", "lesz", "kell",
-         "kellett", "lehet", "tud", "tudott", "fog", "fogja", "azt", "ezt", "ott", "ő", "ők", "én", "te", "mi", "ti",
-         "ön", "önök", "maga", "maguk", "ilyen", "olyan", "amely", "amelyek", "aki", "akik", "ahol", "amikor", "mert",
-         "ezért", "akkor", "így", "úgy", "pedig", "illetve", "továbbá", "azonban", "hanem", "viszont", "nélkül",
-         "alatt", "felett", "között", "előtt", "után", "mellett", "bele", "be", "fel", "le", "át", "szembe", "együtt",
-         "mindig", "soha", "gyakran", "néha", "talán", "esetleg", "biztosan", "nagyon", "kicsit", "éppen", "most",
-         "majd", "azután", "először", "utoljára", "igen", "sem", "túl", "kivéve", "szerint"])
+    "SPELLCHECK_LANG": 'hu'
 }
 
-
 # --- Segédfüggvények ---
 
 def correct_spellings(text, spell_checker_instance):
-    """
-    Kijavítja a helyesírási hibákat a szövegben.
-    """
-    if not spell_checker_instance:
-        return text
+    if not spell_checker_instance: return text
     try:
         words = re.findall(r'\b\w+\b', text.lower())
         misspelled = spell_checker_instance.unknown(words)
-        if not misspelled:
-            return text
-
+        if not misspelled: return text
         corrected_text = text
         for word in misspelled:
             correction = spell_checker_instance.correction(word)
             if correction and correction != word:
-                corrected_text = re.sub(r'\b' + re.escape(word) + r'\b', correction, corrected_text,
-                                        flags=re.IGNORECASE)
+                corrected_text = re.sub(r'\b' + re.escape(word) + r'\b', corrected_text, flags=re.IGNORECASE)
         return corrected_text
     except Exception as e:
         print(f"{RED}Hiba a helyesírás javítása közben: {e}{RESET}")
         return text
 
-
 def get_query_category_with_llm(client, query):
-    """
-    LLM-et használ a felhasználói kérdés kategorizálására, előre definiált listából választva.
-    """
-    if not client:
-        return None
+    if not client: return 'egyéb'
     print(f"  {CYAN}-> Lekérdezés kategorizálása LLM-mel...{RESET}")
-
-    category_list = ['IT biztonsági szolgáltatások', 'szolgáltatások', 'hardver', 'szoftver', 'hírek',
-                     'audiovizuális konferenciatechnika']
+    category_list = ['IT biztonsági szolgáltatások', 'szolgáltatások', 'hardver', 'szoftver', 'hírek', 'audiovizuális konferenciatechnika']
     categories_text = ", ".join([f"'{cat}'" for cat in category_list])
-
-    prompt = f"""Adott egy felhasználói kérdés. Adj meg egyetlen, rövid kategóriát a következő listából, ami a legjobban jellemzi a kérdést. A válaszodban csak a kategória szerepeljen, más szöveg, magyarázat, vagy írásjelek nélkül.
+    prompt = f"""Adott egy felhasználói kérdés. Adj meg egyetlen, rövid kategóriát a következő listából, ami a legjobban jellemzi a kérdést. A válaszodban csak a kategória szerepeljen, más szöveg nélkül.
 Lehetséges kategóriák: {categories_text}
 Kérdés: '{query}'
 Kategória:"""
     messages = [{"role": "user", "content": prompt}]
     try:
-        response = client.chat.completions.create(model=CONFIG["QUERY_EXPANSION_MODEL"], messages=messages,
-                                                  temperature=0.1, max_tokens=30)
+        response = client.chat.completions.create(model=CONFIG["QUERY_EXPANSION_MODEL"], messages=messages, temperature=0.1, max_tokens=30)
         if response and response.choices:
-            category = response.choices[0].message.content.strip()
-            category = re.sub(r'\(.*?\)', '', category).strip()
-            category = re.sub(r'["\']', '', category).strip()
-
+            category = response.choices[0].message.content.strip().replace("'", "").replace("`", "")
             for cat in category_list:
                 if cat.lower() in category.lower():
                     print(f"  {GREEN}-> A kérdés LLM által generált kategóriája: '{cat}'{RESET}")
                     return cat.lower()
-
-            print(f"  {YELLOW}-> Az LLM nem talált megfelelő kategóriát, 'egyéb' kategória használata.{RESET}")
             return 'egyéb'
     except Exception as e:
         print(f"{RED}Hiba LLM kategorizáláskor: {e}{RESET}")
     return 'egyéb'
 
-
 def expand_or_rewrite_query(original_query, client):
-    """
-    Bővíti a felhasználói lekérdezést, hogy több releváns találat legyen.
-    """
     final_queries = [original_query]
-    if not CONFIG["USE_QUERY_EXPANSION"]:
+    if not (CONFIG["USE_QUERY_EXPANSION"] and client):
         return final_queries
-
     print(f"  {BLUE}-> Lekérdezés bővítése/átírása...{RESET}")
-    # JAVÍTOTT PROMPT: csak kulcsszavakat kérünk, magyarázat nélkül
     prompt = f"Adott egy magyar nyelvű felhasználói kérdés: '{original_query}'. Generálj 2 db alternatív, releváns keresőkifejezést. A válaszodban csak ezeket add vissza, vesszővel (,) elválasztva, minden más szöveg nélkül."
     messages = [{"role": "user", "content": prompt}]
     try:
-        response = client.chat.completions.create(model=CONFIG["QUERY_EXPANSION_MODEL"], messages=messages,
-                                                  temperature=0.5, max_tokens=100)
+        response = client.chat.completions.create(model=CONFIG["QUERY_EXPANSION_MODEL"], messages=messages, temperature=0.5, max_tokens=100)
         if response and response.choices:
             generated_text = response.choices[0].message.content.strip()
-            # Módosítva: eltávolítjuk a felesleges karaktereket és magyarázó szöveget
-            alternatives = [q.strip().replace('"', '').replace("'", '').replace('.', '') for q in
-                            generated_text.split(',') if q.strip() and q.strip() != original_query]
+            alternatives = [q.strip().replace('"', '').replace("'", '').replace('.', '') for q in generated_text.split(',') if q.strip() and q.strip() != original_query]
             final_queries.extend(alternatives)
             print(f"  {GREEN}-> Bővített lekérdezések: {final_queries}{RESET}")
     except Exception as e:
         print(f"{RED}Hiba a lekérdezés bővítése során: {e}{RESET}")
     return final_queries
 
-
 def run_separate_searches(es_client, query_text, embedding_model, expanded_queries, query_category=None):
-    """
-    Párhuzamosan futtatja a kulcsszavas és a kNN kereséseket.
-    """
     results = {'knn': {}, 'keyword': {}}
     es_client_with_timeout = es_client.options(request_timeout=CONFIG["ES_CLIENT_TIMEOUT"])
     source_fields = ["text_content", "source_url", "summary", "category"]
-
     filters = []
-
-    # DRASZTIKUS VÁLTOZTATÁS:
-    # A kategóriaszűrés logikája kikapcsolva. A lekérdezés a teljes indexben fut.
-    # Ha a probléma a szűrésben van, ezzel a lépéssel azonosítható.
-    # A felhasználó igénye szerint vissza lehet kapcsolni, de először a teljes működését kell biztosítani.
-    # 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}})
+    
+    if query_category and query_category != 'egyéb':
+        filters.append({"match": {"category": query_category}})
 
     def knn_search(index, query_vector):
         try:
-            knn_query = {"field": "embedding", "query_vector": query_vector, "k": CONFIG["INITIAL_SEARCH_SIZE"],
-                         "num_candidates": CONFIG["KNN_NUM_CANDIDATES"], "filter": filters}
-            response = es_client_with_timeout.search(index=index, knn=knn_query, _source=source_fields,
-                                                     size=CONFIG["INITIAL_SEARCH_SIZE"])
+            knn_query = {"field": "embedding", "query_vector": query_vector, "k": CONFIG["INITIAL_SEARCH_SIZE"], "num_candidates": CONFIG["KNN_NUM_CANDIDATES"], "filter": filters}
+            response = es_client_with_timeout.search(index=index, knn=knn_query, _source=source_fields, size=CONFIG["INITIAL_SEARCH_SIZE"])
             return index, response.get('hits', {}).get('hits', [])
         except Exception as e:
             print(f"{RED}Hiba kNN keresés során ({index}): {e}{RESET}")
@@ -184,51 +135,34 @@ def run_separate_searches(es_client, query_text, embedding_model, expanded_queri
 
     def keyword_search(index, expanded_queries):
         try:
-            should_clauses = []
-            for q in expanded_queries:
-                should_clauses.append({"match": {"text_content": {"query": q, "operator": "OR", "fuzziness": "AUTO"}}})
-
+            should_clauses = [{"match": {"text_content": {"query": q, "operator": "OR", "fuzziness": "AUTO"}}} for q in expanded_queries]
             query_body = {"query": {"bool": {"should": should_clauses, "minimum_should_match": 1, "filter": filters}}}
-            response = es_client_with_timeout.search(index=index, query=query_body['query'], _source=source_fields,
-                                                     size=CONFIG["INITIAL_SEARCH_SIZE"])
+            response = es_client_with_timeout.search(index=index, query=query_body['query'], _source=source_fields, size=CONFIG["INITIAL_SEARCH_SIZE"])
             return index, response.get('hits', {}).get('hits', [])
         except Exception as e:
             print(f"{RED}Hiba kulcsszavas keresés során ({index}): {e}{RESET}")
             return index, []
 
-    query_vector = None
-    try:
-        query_vector = embedding_model.encode(query_text, normalize_embeddings=True).tolist()
-    except Exception as e:
-        print(f"{RED}Hiba az embedding generálásakor: {e}{RESET}")
+    query_vector = embedding_model.encode(query_text, normalize_embeddings=True).tolist() if embedding_model else None
 
     with ThreadPoolExecutor(max_workers=len(CONFIG["VECTOR_INDEX_NAMES"]) * 2) as executor:
-        knn_futures = {executor.submit(knn_search, index, query_vector) for index in CONFIG["VECTOR_INDEX_NAMES"] if
-                       query_vector}
-        keyword_futures = {executor.submit(keyword_search, index, expanded_queries) for index in
-                           CONFIG["VECTOR_INDEX_NAMES"]}
-
+        knn_futures = {executor.submit(knn_search, index, query_vector) for index in CONFIG["VECTOR_INDEX_NAMES"] if query_vector}
+        keyword_futures = {executor.submit(keyword_search, index, expanded_queries) for index in CONFIG["VECTOR_INDEX_NAMES"]}
+        
         for future in knn_futures:
             index, hits = future.result()
             results['knn'][index] = [(rank + 1, hit) for rank, hit in enumerate(hits)]
-
         for future in keyword_futures:
             index, hits = future.result()
             results['keyword'][index] = [(rank + 1, hit) for rank, hit in enumerate(hits)]
 
-    # ÚJ LOGOLÁS: Kiírjuk a keresési találatok számát
     total_knn_hits = sum(len(h) for h in results['knn'].values())
     total_keyword_hits = sum(len(h) for h in results['keyword'].values())
     print(f"{CYAN}Vektorkeresési találatok száma: {total_knn_hits}{RESET}")
     print(f"{CYAN}Kulcsszavas keresési találatok száma: {total_keyword_hits}{RESET}")
-
     return results
 
-
 def merge_results_rrf(search_results):
-    """
-    Egyesíti a keresési eredményeket az RRF algoritmussal.
-    """
     rrf_scores = defaultdict(float)
     all_hits_data = {}
     for search_type in search_results:
@@ -238,184 +172,91 @@ def merge_results_rrf(search_results):
                 rrf_scores[doc_id] += 1.0 / (CONFIG["RRF_RANK_CONSTANT"] + rank)
                 if doc_id not in all_hits_data:
                     all_hits_data[doc_id] = hit
-
-    combined_results = [(doc_id, score, all_hits_data[doc_id]) for doc_id, score in rrf_scores.items()]
-    combined_results.sort(key=lambda item: item[1], reverse=True)
-
-    # ÚJ LOGOLÁS: Kiírjuk az RRF által rangsorolt top 5 pontszámot
-    print(
-        f"{CYAN}RRF által rangsorolt Top 5 pontszám: {[f'{score:.4f}' for doc_id, score, hit in combined_results[:5]]}{RESET}")
-
+    
+    combined_results = sorted([(doc_id, score, all_hits_data[doc_id]) for doc_id, score in rrf_scores.items()], key=lambda item: item[1], reverse=True)
+    print(f"{CYAN}RRF által rangsorolt Top 5 pontszám: {[f'{score:.4f}' for doc_id, score, hit in combined_results[:5]]}{RESET}")
     return combined_results
 
-
 def retrieve_context_reranked(backend, query_text, confidence_threshold, fallback_message, query_category):
-    """
-    Lekéri a kontextust a rangsorolás után.
-    """
-    es_client = backend["es_client"]
-    embedding_model = backend["embedding_model"]
-    cross_encoder = backend["cross_encoder"]
-    llm_client = backend["llm_client"]
-
-    # DRASZTIKUS VÁLTOZTATÁS: A kategória-alapú szűrés kikapcsolva.
-    expanded_queries = expand_or_rewrite_query(query_text, llm_client)
-    search_results = run_separate_searches(es_client, query_text, embedding_model, expanded_queries)
-
+    expanded_queries = expand_or_rewrite_query(query_text, backend["llm_client"])
+    search_results = run_separate_searches(backend["es_client"], query_text, backend["embedding_model"], expanded_queries, query_category)
     merged_results = merge_results_rrf(search_results)
-    top_score = None
-
+    
     if not merged_results:
-        print(f"{YELLOW}A keresés nem hozott eredményt.{RESET}")
-        return fallback_message, [], top_score
-
+        return fallback_message, [], None
+    
     candidates_to_rerank = merged_results[:CONFIG["RE_RANK_CANDIDATE_COUNT"]]
     hits_data_for_reranking = [hit for _, _, hit in candidates_to_rerank]
-
-    query_chunk_pairs = [[query_text, hit['_source'].get('summary', hit['_source'].get('text_content'))] for hit in
-                         hits_data_for_reranking if hit and '_source' in hit]
+    query_chunk_pairs = [[query_text, hit['_source'].get('summary', hit['_source'].get('text_content'))] for hit in hits_data_for_reranking if hit and '_source' in hit]
 
     ranked_by_ce = []
-    if cross_encoder and query_chunk_pairs:
-        try:
-            ce_scores = cross_encoder.predict(query_chunk_pairs, show_progress_bar=False)
-            ranked_by_ce = sorted(zip(ce_scores, hits_data_for_reranking), key=lambda x: x[0], reverse=True)
-            print(f"{CYAN}Cross-Encoder pontszámok (Top 5):{RESET} {[f'{score:.4f}' for score, _ in ranked_by_ce[:5]]}")
-        except Exception as e:
-            print(f"{RED}Hiba a Cross-Encoder során: {e}{RESET}")
-            ranked_by_ce = []
-
-    if not ranked_by_ce and candidates_to_rerank:
-        print(f"{YELLOW}[INFO] Cross-Encoder nem futott, RRF sorrend használata.{RESET}")
-        ranked_by_ce = sorted([(score, hit) for _, score, hit in candidates_to_rerank], key=lambda x: x[0],
-                              reverse=True)
+    if backend["cross_encoder"] and query_chunk_pairs:
+        ce_scores = backend["cross_encoder"].predict(query_chunk_pairs, show_progress_bar=False)
+        ranked_by_ce = sorted(zip(ce_scores, hits_data_for_reranking), key=lambda x: x[0], reverse=True)
+        print(f"{CYAN}Cross-Encoder pontszámok (Top 5):{RESET} {[f'{score:.4f}' for score, _ in ranked_by_ce[:5]]}")
 
     if not ranked_by_ce:
-        return fallback_message, [], top_score
+        return fallback_message, [], None
 
     top_score = float(ranked_by_ce[0][0])
-    print(f"{GREEN}Legjobb találat pontszáma: {top_score:.4f}{RESET}")
-
     if top_score < confidence_threshold:
-        print(
-            f"{YELLOW}A legjobb találat pontszáma ({top_score:.4f}) nem érte el a beállított küszöböt ({confidence_threshold}). A folyamat leáll.{RESET}")
-        dynamic_fallback = (
-            f"{fallback_message}\n\n"
-            f"A '{query_text}' kérdésre a legjobb találat megbízhatósági pontszáma ({top_score:.2f}) "
-            f"nem érte el a beállított küszöböt ({confidence_threshold:.2f})."
-        )
+        dynamic_fallback = (f"{fallback_message}\n\nA '{query_text}' kérdésre a legjobb találat megbízhatósági pontszáma ({top_score:.2f}) nem érte el a beállított küszöböt ({confidence_threshold:.2f}).")
         return dynamic_fallback, [], top_score
 
-    print(f"{GREEN}A Cross-Encoder magabiztos (legjobb score: {top_score:.4f}). A rangsorát használjuk.{RESET}")
     final_hits_for_context = [hit for _, hit in ranked_by_ce[:CONFIG["NUM_CONTEXT_RESULTS"]]]
-
-    context_parts = [hit['_source'].get('summary', hit['_source'].get('text_content')) for hit in final_hits_for_context
-                     if
-                     hit and '_source' in hit and (hit['_source'].get('summary') or hit['_source'].get('text_content'))]
+    context_parts = [hit['_source'].get('summary', hit['_source'].get('text_content')) for hit in final_hits_for_context]
     context_string = "\n\n---\n\n".join(context_parts)
-
-    sources = []
-    for hit_data in final_hits_for_context:
-        if hit_data and '_source' in hit_data:
-            source_info = {
-                "url": hit_data['_source'].get('source_url', hit_data.get('_index', '?')),
-                "content": hit_data['_source'].get('text_content', 'N/A')
-            }
-            if source_info not in sources:
-                sources.append(source_info)
-
+    
+    sources = [{"url": hit['_source'].get('source_url', '?'), "content": hit['_source'].get('text_content', 'N/A')} for hit in final_hits_for_context]
     return context_string, sources, top_score
 
-
 def generate_answer_with_history(client, model_name, messages, temperature):
-    """
-    Válasz generálása LLM-mel, figyelembe véve az előzményeket.
-    """
+    if not client: return "Hiba: Az AI kliens nincs inicializálva."
     try:
-        response = client.chat.completions.create(
-            model=model_name,
-            messages=messages,
-            temperature=temperature,
-            max_tokens=CONFIG["MAX_GENERATION_TOKENS"],
-            timeout=CONFIG["LLM_CLIENT_TIMEOUT"]
-        )
+        response = client.chat.completions.create(model=model_name, messages=messages, temperature=temperature, max_tokens=CONFIG["MAX_GENERATION_TOKENS"], timeout=CONFIG["LLM_CLIENT_TIMEOUT"])
         if response and response.choices:
             return response.choices[0].message.content.strip()
         return "Hiba: Nem érkezett érvényes válasz az AI modelltől."
     except Exception as e:
-        error_message = str(e)
-        if "429" in error_message:
-            wait_time = 100
-            print(f"{YELLOW}Rate limit elérve. A program vár {wait_time} másodpercet...{RESET}")
-            time.sleep(wait_time)
-            return generate_answer_with_history(client, model_name, messages, temperature)
         print(f"{RED}Hiba a válasz generálásakor: {e}{RESET}")
         return "Hiba történt az AI modell hívásakor."
 
-
 def search_in_feedback_index(es_client, embedding_model, question, min_score=0.75):
-    """
-    Keres a visszajelzési adatbázisban a hasonló kérdésekre.
-    """
     try:
+        if not es_client.indices.exists(index=CONFIG["FEEDBACK_INDEX_NAME"]): return None, None
         embedding = embedding_model.encode(question, normalize_embeddings=True).tolist()
         knn_query = {"field": "embedding", "query_vector": embedding, "k": 1, "num_candidates": 10}
-        response = es_client.search(index=CONFIG["FEEDBACK_INDEX_NAME"], knn=knn_query,
-                                    _source=["question_text", "correction_text"])
+        response = es_client.search(index=CONFIG["FEEDBACK_INDEX_NAME"], knn=knn_query, _source=["question_text", "correction_text"])
         hits = response.get('hits', {}).get('hits', [])
         if hits and hits[0]['_score'] >= min_score:
-            top_hit = hits[0]
-            source = top_hit['_source']
-            score = top_hit['_score']
-
-            if score > 0.98:
-                return "direct_answer", source['correction_text']
-
-            instruction = f"Egy nagyon hasonló kérdésre ('{source['question_text']}') korábban a következő javítást/iránymutatást adtad: '{source['correction_text']}'. A válaszodat elsősorban ez alapján alkosd meg, még akkor is, ha a talált kontextus mást sugall!"
+            top_hit = hits[0]; source = top_hit['_source']; score = top_hit['_score']
+            if score > 0.98: return "direct_answer", source['correction_text']
+            instruction = f"Egy nagyon hasonló kérdésre ('{source['question_text']}') korábban a következő javítást/iránymutatást adtad: '{source['correction_text']}'. A válaszodat elsősorban ez alapján alkosd meg!"
             return "instruction", instruction
-
-        return None, None
-    except es_exceptions.NotFoundError:
-        return None, None
     except Exception:
         return None, None
-
+    return None, None
 
 def index_feedback(es_client, embedding_model, question, correction):
-    """
-    Indexeli a visszajelzést.
-    """
     try:
         embedding = embedding_model.encode(question, normalize_embeddings=True).tolist()
-        doc = {"question_text": question, "correction_text": correction, "embedding": embedding,
-               "timestamp": datetime.datetime.now()}
+        doc = {"question_text": question, "correction_text": correction, "embedding": embedding, "timestamp": datetime.datetime.now()}
         es_client.index(index=CONFIG["FEEDBACK_INDEX_NAME"], document=doc)
-        print(f"Visszajelzés sikeresen indexelve a '{CONFIG['FEEDBACK_INDEX_NAME']}' indexbe.")
         return True
     except Exception as e:
         print(f"{RED}Hiba a visszajelzés indexelése során: {e}{RESET}")
         return False
 
-
 def get_all_feedback(es_client, index_name):
-    """
-    Lekéri az összes visszajelzést.
-    """
     try:
-        response = es_client.search(index=index_name, query={"match_all": {}}, size=1000,
-                                    sort=[{"timestamp": {"order": "desc"}}])
+        if not es_client.indices.exists(index=index_name): return []
+        response = es_client.search(index=index_name, query={"match_all": {}}, size=1000, sort=[{"timestamp": {"order": "desc"}}])
         return response.get('hits', {}).get('hits', [])
-    except es_exceptions.NotFoundError:
-        return []
     except Exception as e:
         print(f"{RED}Hiba a visszajelzések listázása során: {e}{RESET}")
         return []
 
-
 def delete_feedback_by_id(es_client, index_name, doc_id):
-    """
-    Töröl egy visszajelzést ID alapján.
-    """
     try:
         es_client.delete(index=index_name, id=doc_id)
         return True
@@ -423,11 +264,7 @@ def delete_feedback_by_id(es_client, index_name, doc_id):
         print(f"{RED}Hiba a visszajelzés törlése során (ID: {doc_id}): {e}{RESET}")
         return False
 
-
 def update_feedback_comment(es_client, index_name, doc_id, new_comment):
-    """
-    Frissít egy visszajelzést ID alapján.
-    """
     try:
         es_client.update(index=index_name, id=doc_id, doc={"correction_text": new_comment})
         return True
@@ -435,119 +272,91 @@ def update_feedback_comment(es_client, index_name, doc_id, new_comment):
         print(f"{RED}Hiba a visszajelzés szerkesztése során (ID: {doc_id}): {e}{RESET}")
         return False
 
-
 def initialize_backend():
-    """
-    Inicializálja a backend komponenseit.
-    """
     print("----- Backend Motor Inicializálása -----")
     load_dotenv()
+
+    es_cloud_id = os.getenv("ES_CLOUD_ID")
+    es_api_key = os.getenv("ES_API_KEY")
+    together_api_key = os.getenv("TOGETHER_API_KEY")
+
+    if not all([es_cloud_id, es_api_key, together_api_key]):
+        print(f"{RED}Hiba: Hiányzó környezeti változók! Szükséges: ES_CLOUD_ID, ES_API_KEY, TOGETHER_API_KEY{RESET}")
+        return None
+    
+    if not TOGETHER_AVAILABLE:
+        print(f"{RED}Hiba: A 'together' csomag nincs telepítve.{RESET}")
+        return None
+
     try:
         nltk.data.find('tokenizers/punkt')
     except LookupError:
         nltk.download('punkt', quiet=True)
 
-    warnings.filterwarnings("ignore", message=".*verify_certs=False.*")
-
     spell_checker = None
     try:
         spell_checker = SpellChecker(language=CONFIG["SPELLCHECK_LANG"])
-        custom_words = ["dunaelektronika", "kft", "outsourcing", "dell", "lenovo", "nis2", "szerver", "kliens",
-                        "hálózati", "hpe"]
+        custom_words = ["dunaelektronika", "kft", "outsourcing", "dell", "lenovo", "nis2", "szerver", "kliens", "hálózati", "hpe"]
         spell_checker.word_frequency.load_words(custom_words)
     except Exception as e:
-        print(f"{RED}Helyesírás-ellenőrző hiba: {e}{RESET}")
-
-    backend_objects = {
-        "es_client": Elasticsearch(CONFIG["ELASTIC_HOST"], basic_auth=("elastic", CONFIG["ELASTIC_PASSWORD"]),
-                                   verify_certs=False),
-        "embedding_model": SentenceTransformer(CONFIG["EMBEDDING_MODEL_NAME"],
-                                               device='cuda' if torch.cuda.is_available() else 'cpu'),
-        "cross_encoder": CrossEncoder(CONFIG["CROSS_ENCODER_MODEL_NAME"],
-                                      device='cuda' if torch.cuda.is_available() else 'cpu'),
-        "llm_client": Together(api_key=os.getenv("TOGETHER_API_KEY")),
-        "spell_checker": spell_checker
-    }
-
-    print(f"{GREEN}----- Backend Motor Készen Áll -----{RESET}")
-    return backend_objects
+        print(f"{RED}Helyesírás-ellenőző hiba: {e}{RESET}")
 
+    try:
+        print(f"{CYAN}Elasticsearch kliens inicializálása...{RESET}")
+        es_client = Elasticsearch(cloud_id=es_cloud_id, api_key=es_api_key, request_timeout=CONFIG["ES_CLIENT_TIMEOUT"])
+        if not es_client.ping(): raise ConnectionError("Elasticsearch ping sikertelen.")
+        print(f"{GREEN}Elasticsearch kliens kész.{RESET}")
+
+        print(f"{CYAN}AI modellek betöltése...{RESET}")
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        embedding_model = SentenceTransformer(CONFIG["EMBEDDING_MODEL_NAME"], device=device)
+        cross_encoder = CrossEncoder(CONFIG["CROSS_ENCODER_MODEL_NAME"], device=device)
+        llm_client = Together(api_key=together_api_key)
+        print(f"{GREEN}AI modellek betöltve (eszköz: {device}).{RESET}")
+
+        backend_objects = {
+            "es_client": es_client, "embedding_model": embedding_model, "cross_encoder": cross_encoder,
+            "llm_client": llm_client, "spell_checker": spell_checker
+        }
+        
+        print(f"{GREEN}----- Backend Motor Készen Áll -----{RESET}")
+        return backend_objects
+    except Exception as e:
+        print(f"{RED}Hiba a backend inicializálása során: {e}{RESET}")
+        return None
 
 def process_query(user_question, chat_history, backend, confidence_threshold, fallback_message):
-    """
-    A teljes lekérdezés-feldolgozási munkafolyamatot vezérli.
-    """
     print(f"\n{BLUE}----- Új lekérdezés feldolgozása ----{RESET}")
     print(f"{BLUE}Kérdés: {user_question}{RESET}")
 
     corrected_question = correct_spellings(user_question, backend["spell_checker"])
     print(f"{BLUE}Javított kérdés: {corrected_question}{RESET}")
 
-    feedback_type, feedback_content = search_in_feedback_index(
-        backend["es_client"], backend["embedding_model"], corrected_question
-    )
-
+    feedback_type, feedback_content = search_in_feedback_index(backend["es_client"], backend["embedding_model"], corrected_question)
     if feedback_type == "direct_answer":
         print(f"{GREEN}Direkt válasz a visszajelzési adatbázisból.{RESET}")
-        return {
-            "answer": feedback_content,
-            "sources": [
-                {"url": "Személyes visszajelzés alapján", "content": "Ez egy korábban megadott, pontosított válasz."}],
-            "corrected_question": corrected_question,
-            "confidence_score": 10.0
-        }
-
-    feedback_instructions = feedback_content if feedback_type == "instruction" else None
+        return {"answer": feedback_content, "sources": [{"url": "Személyes visszajelzés alapján", "content": "Ez egy korábban megadott, pontosított válasz."}], "corrected_question": corrected_question, "confidence_score": 10.0}
 
+    feedback_instructions = feedback_content if feedback_type == "instruction" else ""
     query_category = get_query_category_with_llm(backend["llm_client"], corrected_question)
-
-    retrieved_context, sources, confidence_score = retrieve_context_reranked(backend, corrected_question,
-                                                                             confidence_threshold, fallback_message,
-                                                                             query_category)
+    retrieved_context, sources, confidence_score = retrieve_context_reranked(backend, corrected_question, confidence_threshold, fallback_message, query_category)
 
     if not sources and not feedback_instructions:
-        return {
-            "answer": retrieved_context,
-            "sources": [],
-            "corrected_question": corrected_question,
-            "confidence_score": confidence_score
-        }
-
-    prompt_instructions = ""
-    if feedback_instructions:
-        prompt_instructions = f"""
-KÜLÖNLEGESEN FONTOS FEJLESZTŐI UTASÍTÁS (ezt vedd figyelembe a leginkább!):
----
-{feedback_instructions}
----
-"""
+        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.
-{prompt_instructions}
+{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}'
 KONTEXTUS:
 ---
 {retrieved_context if sources else "A tudásbázisban nem található releváns információ."}
 ---
-ELŐZMÉNYEK (ha releváns): Lásd a korábbi üzeneteket.
 """
-
-    messages_for_llm = []
-    if chat_history:
-        messages_for_llm.extend(chat_history[-(CONFIG["MAX_HISTORY_TURNS"] * 2):])
-
-    messages_for_llm.append({"role": "system", "content": system_prompt})
-    messages_for_llm.append({"role": "user", "content": corrected_question})
-
-    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
-    }
+    messages_for_llm = chat_history[-(CONFIG["MAX_HISTORY_TURNS"] * 2):] if chat_history else []
+    messages_for_llm.extend([{"role": "system", "content": system_prompt}, {"role": "user", "content": corrected_question}])
+    
+    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}