Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,5 +1,5 @@
-import os
 import streamlit as st
+import os
 import pandas as pd
 import numpy as np
 import faiss
@@ -12,7 +12,7 @@ import random
 import tempfile
 import time
 
-# ====== Настройки путей и констант ======
+# --- Настройки путей и констант ---
 HERE = os.path.dirname(os.path.abspath(__file__))
 CSV_PATH = os.path.join(HERE, "tvshows_processed2.csv")
 EMB_PATH = os.path.join(HERE, "embeddings.npy")
@@ -28,8 +28,7 @@ BAD_ACTORS = [
     "нет актёров", "нет актеров", "unknown", "—", ""
 ]
 BAD_PHRASE_PARTS = [
-    "нет описания", "без описания", "неизвестно",
-    "описание отсутствует", "пусто"
+    "нет описания", "без описания", "неизвестно", "описание отсутствует", "пусто"
 ]
 GENRE_KEYWORDS_MAP = {
     "доктор": "драма", "медицина": "драма", "врач": "драма",
@@ -37,10 +36,21 @@ GENRE_KEYWORDS_MAP = {
     "фантастика": "научная фантастика", "боевик": "боевик",
     "криминал": "криминал", "приключения": "приключения",
     "романтика": "романтика", "прогулки": "документальный",
-    "природа": "документальный", "война": "боевик"
+    "природа": "документальный", "война": "боевик",
+    "волшебство": "фэнтези", "дракон": "фэнтези"
 }
 
-# ====== Вспомогательные функции ======
+# --- Вспомогательные функции ---
+def normalize_text(text):
+    """Нормализация текста перед кодированием/поиском: нижний регистр, убрать лишние пробелы и спецсимволы."""
+    text = "" if text is None else str(text)
+    text = text.strip().lower()
+    text = re.sub(r"\s+", " ", text)
+    # Оставляем буквы, цифры, пробелы и дефис
+    text = re.sub(r"[^\w\sа-яё\-]", " ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
 def list_str_to_text(x):
     try:
         lst = ast.literal_eval(x) if isinstance(x, str) else x
@@ -76,6 +86,7 @@ def clean_tvshows_data(path):
     df["tvshow_title"] = df.get("tvshow_title", "").fillna("Неизвестно")
     df["description"] = df.get("description", "").fillna("Нет описания").astype(str).str.strip()
 
+    # Оставляем записи с длиной описания >= 15 слов
     df = df[df["description"].apply(lambda x: len(str(x).split()) >= 15)]
 
     garbage_patterns = [
@@ -86,27 +97,23 @@ def clean_tvshows_data(path):
         r"(нет[.,\s]*){5,}",
         r"(\s*15\s*лет\s*){2,}",
         r"(\s*ё\s*){2,}",
-        r"(\s*ј\s*){2,}",
-        r"(\s*ѕј\s*){2,}",
         r"(.)\1{3,}",
         r"(\s*[.,;!?'`~]{2,}\s*)",
         r"(\s*[0-9]{2,}\s*)",
     ]
-
     def matches_garbage(text):
         t = str(text).lower()
         return any(re.search(p, t) for p in garbage_patterns)
-
     df = df[~df["description"].apply(matches_garbage)]
-    
+
     try:
         to_drop_exact = df["description"].value_counts()[lambda x: x >= 3].index
         df = df[~df["description"].isin(to_drop_exact)]
     except Exception:
         pass
-    
+
     df = df[~df["description"].str.lower().apply(lambda text: any(phrase in text for phrase in BAD_PHRASE_PARTS))]
-    
+
     cols_to_ignore = {
         'tvshow_title','year','genres','actors','rating','description',
         'image_url','url','language','country','directors','page_url','num_seasons'
@@ -120,7 +127,7 @@ def clean_tvshows_data(path):
             df[col] = None
     return df.reset_index(drop=True)
 
-# ====== Кэширование и инициализация ======
+# --- Кэширование и инициализация ---
 @st.cache_data
 def cached_load_data(path):
     return clean_tvshows_data(path)
@@ -129,45 +136,57 @@ def cached_load_data(path):
 def cached_init_embedder():
     cache_dir = os.path.join(tempfile.gettempdir(), "sbert_cache")
     os.makedirs(cache_dir, exist_ok=True)
+    # Модель русскоязычная как в оригинале
     return SentenceTransformer("sberbank-ai/sbert_large_nlu_ru", cache_folder=cache_dir)
 
 @st.cache_resource
 def cached_load_embeddings_and_index():
+    """
+    Загружает/создаёт эмбеддинги и FAISS-индекс.
+    При создании эмбеддингов — применяется нормализация текста и расширенный контекст.
+    """
     if not os.path.exists(EMB_PATH) or not os.path.exists(FAISS_PATH):
         st.warning("Файлы эмбеддингов или индекса не найдены. Создаем новые...")
         df = cached_load_data(CSV_PATH)
         embedder = cached_init_embedder()
-        
-        texts = df["tvshow_title"] + " " + df["description"] + " " + df["genres"] + " " + df["actors"]
-        
-        embeddings = embedder.encode(texts.tolist(), show_progress_bar=True)
+
+        texts = df.apply(
+            lambda row: (
+                f"название: {normalize_text(row['tvshow_title'])}. "
+                f"описание: {normalize_text(row['description'])}. "
+                f"жанр: {normalize_text(row['genres'])}. "
+                f"актёры: {normalize_text(row['actors'])}. "
+                f"год: {row['year']}. "
+                f"тип: {normalize_text(row['type'])}. "
+                f"страна: {normalize_text(row.get('country', ''))}."
+            ),
+            axis=1
+        ).tolist()
+
+        embeddings = embedder.encode(texts, show_progress_bar=True)
+        # Убедимся, что float32
+        embeddings = np.asarray(embeddings).astype('float32')
         faiss.normalize_L2(embeddings)
         np.save(EMB_PATH, embeddings)
-        
+
         index = faiss.IndexFlatIP(embeddings.shape[1])
         index.add(embeddings)
         faiss.write_index(index, FAISS_PATH)
-        
-        st.success("Новые эмбеддинги и индекс успешно созданы. Пожалуйста, обновите страницу, чтобы продолжить.")
-        
+
+        st.success("Новые эмбеддинги и индекс успешно созданы. Обновите страницу.")
+
     embeddings = np.load(EMB_PATH)
     index = faiss.read_index(FAISS_PATH)
     return embeddings, index
 
-
-@st.cache_resource
-def cached_init_groq_llm():
-    api_key = os.getenv("GROQ_API_KEY")
-    if not api_key:
-        return None
-    try:
-        os.environ["GROQ_API_KEY"] = api_key
-        return ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0, max_tokens=2000)
-    except Exception as e:
-        st.error(f"Ошибка инициализации Groq: {e}")
+@st.cache_resource(ttl=3600)
+def init_groq_llm():
+    key = st.secrets.get("GROQ_API_KEY") or st.text_input("🔐 Введите API-ключ Groq:", type="password")
+    if not key:
         return None
+    os.environ["GROQ_API_KEY"] = key
+    return ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0, max_tokens=2000)
 
-# ====== Автоматическое определение жанра из запроса ======
 def infer_genre_from_query(query):
     query_lower = query.lower()
     for keyword, genre in GENRE_KEYWORDS_MAP.items():
@@ -175,87 +194,125 @@ def infer_genre_from_query(query):
             return genre
     return None
 
-# ====== Семантический поиск с улучшенной фильтрацией и ранжированием ======
-def semantic_search(query, embedder, index, df, genre=None, year=None, country=None, vtype=None, k=5):
+# --- Семантический поиск с улучшениями (нормализация, фильтрация перед поиском, гибридное ранжирование) ---
+def semantic_search(query, embedder, index, df, genre=None, year=None, country=None, vtype=None, k=5, debug=False):
+    """
+    Возвращает DataFrame с top-k результатами.
+    Параметр debug включит печать отладочной информации в лог.
+    """
     if not isinstance(query, str) or not query.strip():
         return pd.DataFrame()
-    
-    print(f"Пользовательский запрос: {query}") # Отладочный вывод
-    
-    inferred_genre = infer_genre_from_query(query)
+
+    # Нормализуем запрос
+    query_norm = normalize_text(query)
+    inferred_genre = infer_genre_from_query(query_norm)
     if inferred_genre and (genre is None or genre == "Все"):
         genre = inferred_genre
 
-    query_embedding = embedder.encode([query])
-    faiss.normalize_L2(query_embedding)
-
-    n_search = 500
-    dists, idxs = index.search(query_embedding, n_search)
-
-    valid_idxs = [i for i in idxs[0] if i >= 0 and i < len(df)]
-    if not valid_idxs:
-        return pd.DataFrame()
-
-    res = df.iloc[valid_idxs].copy()
-    res["score"] = dists[0][:len(valid_idxs)]
-
+    # 1) Предварительная фильтрация по атрибутам (чтобы не терять подходящие результаты позже)
+    filtered_df = df
     if genre and genre != "Все":
-        genre_lower = genre.lower()
-        res = res[res["basic_genres"].str.lower().str.contains(genre_lower, na=False)]
-
+        filtered_df = filtered_df[filtered_df["basic_genres"].str.lower().str.contains(str(genre).lower(), na=False)]
     if year and year != "Все":
         try:
-            res = res[res["year"] == int(year)]
+            filtered_df = filtered_df[filtered_df["year"] == int(year)]
         except:
             pass
-
     if country and country != "Все":
-        country_lower = country.lower()
-        res = res[res["country"].astype(str).str.lower().str.contains(country_lower, na=False)]
-
+        filtered_df = filtered_df[filtered_df["country"].astype(str).str.lower().str.contains(str(country).lower(), na=False)]
     if vtype and vtype != "Все":
-        res = res[res["type"].str.lower() == vtype.lower()]
+        filtered_df = filtered_df[filtered_df["type"].str.lower() == vtype.lower()]
+
+    if filtered_df.empty:
+        if debug:
+            print(f"[DEBUG] После предварительной фильтрации ничего не осталось (жанр={genre}, год={year}, страна={country}, тип={vtype}).")
+        return pd.DataFrame()
 
-    if res.empty:
-        return res
+    filtered_indices = set(filtered_df.index.to_list())
 
-    query_lower = query.lower()
-    
-    res['exact_match_title'] = res['tvshow_title'].str.lower() == query_lower
-    
-    query_words = re.findall(r'\b\w+\b', query_lower)
-    keyword_pattern = '|'.join([re.escape(word) for word in query_words if len(word) > 2])
-    
+    # 2) Кодируем запрос и ищем топ-N в индексе (N с запасом)
+    query_embedding = embedder.encode([query_norm]).astype('float32')
+    faiss.normalize_L2(query_embedding)
+
+    # n_search: максимум размер индекса или 2000, чтобы взять с запасом
+    ntotal = index.ntotal if hasattr(index, "ntotal") else len(df)
+    n_search = min(max(1000, k * 50), ntotal)  # разумный диапазон: минимум 1000, максимум ntotal
+    dists, idxs = index.search(query_embedding, n_search)
+
+    # 3) Оставляем только индексы, которые прошли предварительную фильтрацию
+    final_idxs = []
+    final_dists = []
+    for dist, idx in zip(dists[0], idxs[0]):
+        if idx < 0:
+            continue
+        if idx in filtered_indices:
+            final_idxs.append(idx)
+            final_dists.append(float(dist))
+        # остановка, когда набрали достаточно кандидатов (с запасом)
+        if len(final_idxs) >= k * 6:
+            break
+
+    if not final_idxs:
+        if debug:
+            print("[DEBUG] Поиск ничего не нашел среди отфильтрованных записей.")
+        return pd.DataFrame()
+
+    # 4) Собираем DataFrame результатов и применяем гибридное ранжирование
+    res = df.loc[final_idxs].copy()
+    res["score"] = final_dists  # базовый скор от эмбеддинга (IP / косинус)
+    # exact title match (строгий)
+    res['exact_match_title'] = res['tvshow_title'].str.lower().str.strip() == query_norm
+    # keyword presence: конструкция из слов запроса (слова длинее 2 символов)
+    query_words = re.findall(r'\b\w+\b', query_norm)
+    keyword_pattern = '|'.join([re.escape(w) for w in query_words if len(w) > 2])
     if keyword_pattern:
         res['has_keyword'] = res.apply(
-            lambda row: bool(re.search(keyword_pattern, str(row['tvshow_title']).lower())) or
-                        bool(re.search(keyword_pattern, str(row['description']).lower())),
+            lambda row: bool(re.search(keyword_pattern, normalize_text(str(row.get('tvshow_title', ''))))) or
+                        bool(re.search(keyword_pattern, normalize_text(str(row.get('description', ''))))),
             axis=1
         )
     else:
         res['has_keyword'] = False
-        
-    res['final_score'] = res['score']
-    
-    res['final_score'] = np.where(res['exact_match_title'], res['final_score'] + 1.5, res['final_score'])
-    res['final_score'] = np.where(res['has_keyword'], res['final_score'] + 0.4, res['final_score'])
-    
+
+    # Прибавляем бонусы: более агрессивные веса для exact title и keyword
+    res['final_score'] = res['score'].astype(float)
+    res['final_score'] = np.where(res['exact_match_title'], res['final_score'] + 2.0, res['final_score'])
+    res['final_score'] = np.where(res['has_keyword'], res['final_score'] + 0.6, res['final_score'])
+
+    # Можно также учитывать совпадение жанра (если пользователь явно указал)
+    if genre and genre != "Все":
+        # Если basic_genres содержит целевой жанр — маленький бонус
+        res['genre_match'] = res['basic_genres'].str.lower().str.contains(genre.lower(), na=False)
+        res['final_score'] = np.where(res['genre_match'], res['final_score'] + 0.2, res['final_score'])
+    else:
+        res['genre_match'] = False
+
+    # 5) Логирование (вывод в консоль и в сайдбар, если нужно)
+    if debug:
+        print(f"[DEBUG] Запрос: {query_norm}")
+        print(f"[DEBUG] Количество кандидатов после initial search: {len(idxs[0])}")
+        print(f"[DEBUG] Количество результатов после фильтрации: {len(res)}")
+        print(res[['tvshow_title', 'score', 'final_score', 'exact_match_title', 'has_keyword']].head(15))
+        try:
+            st.sidebar.markdown("#### Debug: последние результаты поиска")
+            st.sidebar.dataframe(res[['tvshow_title', 'score', 'final_score', 'exact_match_title', 'has_keyword']].head(10))
+        except Exception:
+            pass
+
     sorted_results = res.sort_values(by="final_score", ascending=False)
-    
     return sorted_results.head(k)
 
-
-# ====== Форматирование результатов для LLM ======
+# --- Форматирование результатов для LLM и RAG ---
 def format_docs_for_prompt(results_df):
     parts = []
-    if results_df.empty:
+    if results_df is None or results_df.empty:
         return "Нет подходящих результатов поиска в базе данных."
     for _, row in results_df.iterrows():
         parts.append(
-            f"Название: {row['tvshow_title']} ({row['year']})\n"
+            f"Название: {row['tvshow_title']} ({int(row['year']) if not pd.isna(row['year']) else '—'})\n"
             f"Жанр: {row['basic_genres']}\n"
             f"Рейтинг: {row['rating'] or '—'} | Тип: {row['type']} | "
-            f"Страна: {row['country'] or '—'} | Сезонов: {row['num_seasons'] or '—'}\n"
+            f"Страна: {row['country'] or '—'} | Сезонов: {int(row['num_seasons']) if not pd.isna(row['num_seasons']) else '—'}\n"
             f"Актёры: {row['actors']}\nСюжет: {extract_intro_paragraph(row['description'])}"
         )
     return "\n\n".join(parts)
@@ -263,28 +320,25 @@ def format_docs_for_prompt(results_df):
 def generate_rag_response(user_query, search_results, llm):
     if llm is None:
         return "LLM не инициализирован."
-    
-    ctx = format_docs_for_prompt(search_results)
 
+    ctx = format_docs_for_prompt(search_results)
     prompt_template = """
-    Ты — эксперт по кино и сериалам. Твоя задача — помочь пользователю, основываясь на предоставленных ниже результатах поиска.
+Ты — эксперт по кино и сериалам. Твоя задача — помочь пользователю, основываясь на предоставленных ниже результатах поиска.
 
-    Твой основной источник информации — предоставленные результаты поиска.
-    1.  Сначала проанализируй, насколько предоставленные результаты поиска релевантны запросу пользователя.
-    2.  Если результаты релевантны, объясни почему и суммируй их.
-    3.  Если результаты нерелевантны, **прямо об этом скажи** и объясни, что в базе данных не найдено ничего подходящего.
-    4.  В любом случае, после анализа, предложи **1-2 дополнительных фильма или сериала, которые идеально подходят** под запрос пользователя, используя только свои общие знания, даже если их нет в результатах поиска.
+Твой основной источник информации — предоставленные результаты поиска.
+1. Сначала проанализируй, насколько предоставленные результаты поиска релевантны запросу пользователя.
+2. Если результаты релевантны, объясни почему и суммируй их.
+3. Если результаты нерелевантны, прямо об этом скажи и объясни, что в базе данных не найдено ничего подходящего.
+4. В любом случае, после анализа, предложи 1-2 дополнительных фильма или сериала, которые идеально подходят под запрос пользователя, используя только свои общие знания, даже если их нет в результатах поиска.
 
-    Результаты поиска:
-    {context}
+Результаты поиска:
+{context}
 
-    Вопрос пользователя: {question}
+Вопрос пользователя: {question}
 
-    Ответ:
-    """
-    
+Ответ:
+"""
     full_prompt = prompt_template.format(context=ctx, question=user_query)
-    
     try:
         response = llm.invoke([
             SystemMessage(content="Ты — эксперт по кино и сериалам. Всегда основывайся на предоставленном контексте и не придумывай лишнего."),
@@ -294,56 +348,38 @@ def generate_rag_response(user_query, search_results, llm):
     except Exception as e:
         return f"Ошибка при генерации ответа LLM: {e}"
 
-# ====== UI: main ======
+# --- UI: main ---
 def main():
-    st.set_page_config(page_title="Поиск фильмов и сериалов + AI", layout="wide")
-    st.title("Семантический поиск фильмов и сериалов с AI")
+    st.set_page_config(page_title="🎬 Поиск фильмов и сериалов + Groq AI", layout="wide")
+    st.title("📽️ Семантический поиск фильмов и сериалов с AI")
 
+    # Инициализация данных/ресурсов
     if "df" not in st.session_state:
-        try:
-            st.session_state.df = cached_load_data(CSV_PATH)
-        except FileNotFoundError as e:
-            st.error(str(e))
-            return
-
+        st.session_state.df = cached_load_data(CSV_PATH)
     if "embedder" not in st.session_state:
-        try:
-            st.session_state.embedder = cached_init_embedder()
-        except Exception as e:
-            st.error(f"Ошибка инициализации embedder: {e}")
-            return
-
+        st.session_state.embedder = cached_init_embedder()
     if "embeddings_index" not in st.session_state:
-        try:
-            with st.spinner("Загрузка эмбеддингов и индекса (может занять несколько минут при первом запуске)..."):
-                st.session_state.embeddings, st.session_state.index = cached_load_embeddings_and_index()
-        except FileNotFoundError as e:
-            st.error(str(e))
-            return
-        except Exception as e:
-            st.error(f"Ошибка загрузки индекса/эмбеддингов: {e}")
-            return
-
+        with st.spinner("Загрузка эмбеддингов и индекса..."):
+            st.session_state.embeddings, st.session_state.index = cached_load_embeddings_and_index()
     if "llm" not in st.session_state:
-        st.session_state.llm = cached_init_groq_llm()
+        st.session_state.llm = init_groq_llm()
+
+    if 'last_query' not in st.session_state: st.session_state.last_query = ""
+    if 'results' not in st.session_state: st.session_state.results = pd.DataFrame()
+    if 'ai_clicked' not in st.session_state: st.session_state.ai_clicked = False
 
     df = st.session_state.df
     embedder = st.session_state.embedder
     index = st.session_state.index
     llm = st.session_state.llm
 
-    # Инициализация переменных состояния
-    if 'last_query' not in st.session_state:
-        st.session_state.last_query = ""
-    if 'results' not in st.session_state:
-        st.session_state.results = pd.DataFrame()
-    if 'ai_clicked' not in st.session_state:
-        st.session_state.ai_clicked = False
-    if 'search_query' not in st.session_state:
-        st.session_state.search_query = ""
-
+    # Sidebar: debug toggle + информация
+    st.sidebar.markdown("---")
+    debug_mode = st.sidebar.checkbox("Включить debug-логи", value=False)
+    st.sidebar.markdown("## ℹ️ Информация")
+    st.sidebar.write(f"Всего записей в базе: {len(df)}")
+    st.sidebar.markdown(f"**Статус Groq LLM:** {'🟢 Готов' if llm else '🔴 Отключён (нужен API-ключ)'}")
 
-    # ====== Форма поиска ======
     with st.container():
         st.markdown("---")
         with st.form(key='search_form'):
@@ -362,40 +398,43 @@ def main():
                 vtypes = ["Все"] + sorted(df["type"].dropna().unique())
                 type_filter = st.selectbox("Тип", vtypes, index=0, key="type_filter_key")
 
-            k = st.slider("Количество результатов:", 1, 20, 5, key="k_slider")
-            user_input = st.text_input("Введите ключевые слова или сюжет:", key="user_input_key")
+            k = st.slider("📊 Количество результатов:", 1, 20, 5, key="k_slider")
+            user_input = st.text_input("🔎 Введите ключевые слова или сюжет:", key="user_input_key")
 
             col_buttons = st.columns(4)
             with col_buttons[0]:
-                random_search = st.form_submit_button("Случайный фильм/сериал")
+                random_search = st.form_submit_button("🎲 Случайный фильм/сериал")
             with col_buttons[1]:
-                genre_search = st.form_submit_button("ТОП по жанру")
+                genre_search = st.form_submit_button("🔥 ТОП по жанру")
             with col_buttons[2]:
-                new_search = st.form_submit_button("Новинки")
+                new_search = st.form_submit_button("🆕 Новинки")
             with col_buttons[3]:
-                text_search = st.form_submit_button("Искать")
+                text_search = st.form_submit_button("🔍 Искать")
 
-    # Логика обработки нажатий кнопок
-    if text_search and user_input:
-        st.session_state.last_query = user_input
-        st.session_state.results = semantic_search(
-            user_input, embedder, index, df,
-            genre_filter, year_filter, country_filter, type_filter, k
-        )
-        st.session_state.ai_clicked = False
+    # Обработка кнопок поиска
+    if text_search:
+        if not user_input.strip():
+            st.warning("Введите запрос для поиска.")
+        else:
+            st.session_state.last_query = user_input
+            st.session_state.results = semantic_search(
+                user_input, embedder, index, df,
+                genre_filter, year_filter, country_filter, type_filter, k, debug=debug_mode
+            )
+            st.session_state.ai_clicked = False
     elif random_search:
         random_query = random.choice(df["tvshow_title"].tolist())
         st.session_state.last_query = random_query
         st.session_state.results = semantic_search(
             random_query, embedder, index, df,
-            genre_filter, year_filter, country_filter, type_filter, k
+            genre_filter, year_filter, country_filter, type_filter, k, debug=debug_mode
         )
         st.session_state.ai_clicked = False
     elif genre_search and genre_filter != "Все":
         st.session_state.last_query = f"Лучшие фильмы и сериалы в жанре {genre_filter}"
         st.session_state.results = semantic_search(
             st.session_state.last_query, embedder, index, df,
-            genre_filter, year_filter, country_filter, type_filter, k
+            genre_filter, year_filter, country_filter, type_filter, k, debug=debug_mode
         )
         st.session_state.ai_clicked = False
     elif new_search:
@@ -403,66 +442,61 @@ def main():
         st.session_state.last_query = new_query
         st.session_state.results = semantic_search(
             new_query, embedder, index, df,
-            genre_filter, year_filter, country_filter, type_filter, k
+            genre_filter, year_filter, country_filter, type_filter, k, debug=debug_mode
         )
         st.session_state.ai_clicked = False
 
-    # ====== Отрисовка результатов ======
     results_container = st.container()
     ai_response_container = st.container()
 
     with results_container:
-        st.markdown("## Результаты поиска")
+        st.markdown("## 🔎 Результаты поиска")
         results_exist = isinstance(st.session_state.get("results"), pd.DataFrame) and not st.session_state.results.empty
-        
+
         if not results_exist:
             if st.session_state.last_query:
-                st.warning(f"Ничего не найдено по запросу: '{st.session_state.last_query}'.")
+                st.warning(f"🤷 Ничего не найдено по запросу: '{st.session_state.last_query}'.")
             else:
-                st.info("Введите запрос и нажмите «Искать», или выберите «Случайный фильм/сериал».")
+                st.info("👋 Введите запрос или выберите один из вариантов ниже.")
         else:
             res_df = st.session_state.results
-            st.success(f"Найдено: {len(res_df)}")
+            st.success(f"✅ Найдено: {len(res_df)}")
             for _, row in res_df.iterrows():
-                card_cols = st.columns([1, 3])
-                with card_cols[0]:
+                col1, col2 = st.columns([1, 3])
+                with col1:
                     image_url = row.get("image_url")
                     if image_url and isinstance(image_url, str) and (image_url.startswith('http') or image_url.startswith('https')):
                         try:
                             st.image(image_url, width=150)
                         except Exception:
-                            st.info("Не удалось загрузить изображение.")
+                            st.info("🤷‍♂️ Нет изображения.")
                     else:
-                        st.info("Нет изображения.")
-                with card_cols[1]:
+                        st.info("🤷‍♂️ Нет изображения.")
+                with col2:
                     st.markdown(f"### {row['tvshow_title']} ({row['year']})")
-                    st.caption(f"{row['basic_genres']} | {row['country'] or '—'} | {row['rating'] or '—'} | {row['type']} | {row['num_seasons']} сез.")
+                    st.caption(
+                        f"🎭 {row['basic_genres']} | 📍 {row['country'] or '—'}"
+                        f" | ⭐ {row['rating'] or '—'}"
+                        f" | �� {row['type']} | 📺 {row['num_seasons']} сез."
+                    )
                     st.write(extract_intro_paragraph(row["description"]))
                     if row.get("actors"):
-                        st.caption(f"Актёры: {row['actors']}")
+                        st.caption(f"👥 Актёры: {row['actors']}")
                     if row.get("url"):
-                        st.markdown(f"[Подробнее]({row['url']})")
+                        st.markdown(f"[🔗 Подробнее]({row['url']})")
                 st.divider()
 
-    # Кнопка для AI-генерации вне формы
-    if st.session_state.llm and not st.session_state.results.empty:
-        if st.button("AI: почему эти подходят и что ещё посмотреть", key="ai_button"):
+    # Кнопка AI для RAG-ответа
+    if st.session_state.llm and isinstance(st.session_state.get("results"), pd.DataFrame) and not st.session_state.results.empty:
+        if st.button("🧠 AI: почему эти подходят и что ещё посмотреть", key="ai_button"):
             st.session_state.ai_clicked = True
-    
+
     with ai_response_container:
         if st.session_state.get("ai_clicked") and st.session_state.get("last_query"):
-            st.markdown("### Рекомендации AI:")
+            st.markdown("### 🤖 Рекомендации AI:")
             with st.spinner("Генерация ответа AI..."):
                 rag = generate_rag_response(st.session_state.last_query, st.session_state.results, llm)
                 st.write(rag)
-        elif st.session_state.get("ai_clicked") and not st.session_state.get("results").empty:
-            st.markdown("### Рекомендации AI:")
-            with st.spinner("Генерация ответа AI..."):
-                rag = generate_rag_response(st.session_state.last_query, st.session_state.results, llm)
-                st.write(rag)
-
-    st.sidebar.write(f"Всего записей: {len(df)}")
-    st.sidebar.markdown(f"**Статус LLM:** {'Готов' if llm else 'Отключён (нет API-ключа)'}")
 
 if __name__ == "__main__":
     main()