Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,5 +1,7 @@
-import streamlit as st
+
+
 import os
+import streamlit as st
 import pandas as pd
 import numpy as np
 import faiss
@@ -10,38 +12,28 @@ from langchain_core.messages import SystemMessage, HumanMessage
 import ast
 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")
 FAISS_PATH = os.path.join(HERE, "faiss_index.index")
 
-# --- Базовые жанры для нормализации ---
 BASIC_GENRES = [
     "комедия", "драма", "боевик", "фэнтези", "ужасы", "триллер", "романтика",
     "научная фантастика", "приключения", "криминал", "мюзикл",
-    "семейный", "детектив", "биография", "документальный"
+    "семейный", "детектив", "биография"
 ]
 BAD_ACTORS = [
     "я не знаю что делать", "я не знаю", "нет информации", "не указан",
     "нет актёров", "нет актеров", "unknown", "—", ""
 ]
 BAD_PHRASE_PARTS = [
-    "нет описания", "без описания", "неизвестно", "описание отсутствует", "пусто"
+    "нет описания", "без описания", "неизвестно",
+    "описание отсутствует", "пусто"
 ]
-GENRE_KEYWORDS_MAP = {
-    "доктор": "драма", "медицина": "драма", "врач": "драма",
-    "школа": "драма", "комедия": "комедия", "ужас": "ужасы",
-    "фантастика": "научная фантастика", "боевик": "боевик",
-    "криминал": "криминал", "приключения": "приключения",
-    "романтика": "романтика", "прогулки": "документальный",
-    "природа": "документальный", "война": "боевик",
-    "волшебство": "фэнтези", "дракон": "фэнтези"
-}
 
-# --- Вспомогательные функции ---
+# ====== Вспомогательные функции ======
 def list_str_to_text(x):
     try:
         lst = ast.literal_eval(x) if isinstance(x, str) else x
@@ -76,40 +68,31 @@ def clean_tvshows_data(path):
     df["num_seasons"] = pd.to_numeric(df.get("num_seasons", 0), errors="coerce").fillna(0).astype(int)
     df["tvshow_title"] = df.get("tvshow_title", "").fillna("Неизвестно")
     df["description"] = df.get("description", "").fillna("Нет описания").astype(str).str.strip()
-    df = df[df["description"].apply(lambda x: len(str(x).split()) >= 15)]
-
+    df = df[df["description"].apply(lambda x: len(str(x).split())) >= 15]
+    try:
+        to_drop_exact = df["description"].value_counts()[lambda x: x >= 3].index
+        df = df[~df["description"].isin(to_drop_exact)]
+    except Exception:
+        pass
     garbage_patterns = [
         r"(всё в порядке[.!?~ ,]*){3,}",
         r"(я не знаю[^.!?]*){2,}",
         r"(ладно[.,\s]*){3,}",
         r"(о[ауе]?[^\w]*){5,}",
         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'
     }
-    genre_onehots = [c for c in df.columns if c not in cols_to_ignore and df[c].nunique() <= 2]
+    genre_onehots = [
+        c for c in df.columns if c not in cols_to_ignore and df[c].nunique() <= 2
+    ]
     df = df.drop(columns=genre_onehots, errors="ignore")
     df["basic_genres"] = df["genres"].apply(filter_to_basic_genres)
     df["type"] = df["num_seasons"].apply(lambda x: "Сериал" if pd.notna(x) and int(x) > 1 else "Фильм")
@@ -118,7 +101,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)
@@ -132,222 +115,158 @@ def cached_init_embedder():
 @st.cache_resource
 def cached_load_embeddings_and_index():
     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.apply(
-            lambda row: f"Название: {row['tvshow_title']}. Описание: {row['description']}. Жанр: {row['genres']}. Актеры: {row['actors']}.",
-            axis=1
-        ).tolist()
-        
-        embeddings = embedder.encode(texts, show_progress_bar=True)
-        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("Новые эмбеддинги и индекс успешно созданы. Пожалуйста, обновите страницу, чтобы продолжить.")
-        
+        raise FileNotFoundError("Файлы embeddings.npy или faiss_index.index не найдены.")
     embeddings = np.load(EMB_PATH)
     index = faiss.read_index(FAISS_PATH)
     return embeddings, index
 
-@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():
-        if keyword in query_lower:
-            return genre
-    return None
+@st.cache_resource
+def cached_init_groq_llm():
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        return None  # Возвращаем None, если ключ не установлен
+    try:
+        os.environ["GROQ_API_KEY"] = api_key # Убедимся, что LangChain его видит
+        return ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0, max_tokens=2000)
+    except Exception as e:
+        st.error(f"Ошибка инициализации Groq: {e}")
+        return None
 
-# --- Семантический поиск с гибридным ранжированием ---
+# ====== Поисковые/вспомогательные функции ======
 def semantic_search(query, embedder, index, df, genre=None, year=None, country=None, vtype=None, k=5):
     if not isinstance(query, str) or not query.strip():
         return pd.DataFrame()
-    
-    inferred_genre = infer_genre_from_query(query)
-    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  # Увеличили количество для более широкого поиска
+    n_search = max(k*3, 1)
     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)]
-
-    # Применяем фильтрацию
     if genre and genre != "Все":
-        genre_lower = genre.lower()
-        res = res[res["basic_genres"].str.lower().str.contains(genre_lower, na=False)]
-
+        res = res[res["basic_genres"].str.contains(genre, na=False)]
     if year and year != "Все":
         try:
             res = res[res["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)]
-
+        res = res[res["country"].astype(str).str.contains(country, na=False)]
     if vtype and vtype != "Все":
-        res = res[res["type"].str.lower() == vtype.lower()]
-
+        res = res[res["type"] == vtype]
     if res.empty:
         return res
+    return res.nlargest(k, "score")
 
-    # --- Гибридное ранжирование ---
-    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])
-    
-    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())),
-            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'])
-    
-    sorted_results = res.sort_values(by="final_score", ascending=False)
-    
-    return sorted_results.head(k)
-
-# --- Форматирование результатов для LLM ---
 def format_docs_for_prompt(results_df):
     parts = []
-    if results_df.empty:
-        return "Нет подходящих результатов поиска в базе данных."
     for _, row in results_df.iterrows():
         parts.append(
-            f"Название: {row['tvshow_title']} ({row['year']})\n"
+            f"{row['tvshow_title']} ({row['year']})\n"
             f"Жанр: {row['basic_genres']}\n"
             f"Рейтинг: {row['rating'] or '—'} | Тип: {row['type']} | "
-            f"Страна: {row['country'] or '—'} | Сезонов: {row['num_seasons'] or '—'}\n"
-            f"Актёры: {row['actors']}\nСюжет: {extract_intro_paragraph(row['description'])}"
+            f"Страна: {row['country'] or '—'} | Сезонов: {row['num_seasons']}\n"
+            f"Актёры: {row['actors']}\n{extract_intro_paragraph(row['description'])}"
         )
     return "\n\n".join(parts)
 
 def generate_rag_response(user_query, search_results, llm):
-    if llm is None:
-        return "LLM не инициализирован."
-    
+    if llm is None or search_results.empty:
+        return "LLM не инициализирован или нет результатов для анализа."
     ctx = format_docs_for_prompt(search_results)
-    
-    prompt_template = """
-    Ты — эксперт по кино и сериалам. Твоя задача — помочь пользователю, основываясь на предоставленных ниже результатах поиска.
-
-    Твой основной источник информации — предоставленные результаты поиска.
-    1.  Сначала проанализируй, насколько предоставленные результаты поиска релевантны запросу пользователя.
-    2.  Если результаты релевантны, объясни почему и суммируй их.
-    3.  Если результаты нерелевантны, **прямо об этом скажи** и объясни, что в базе данных не найдено ничего подходящего.
-    4.  В любом случае, после анализа, предложи **1-2 дополнительных фильма или сериала, которые идеально подходят** под запрос пользователя, используя только свои общие знания, даже если их нет в результатах поиска.
-
-    Результаты поиска:
-    {context}
-
-    Вопрос пользователя: {question}
-
-    Ответ:
-    """
-    
-    full_prompt = prompt_template.format(context=ctx, question=user_query)
-    
     try:
-        response = llm.invoke([
-            SystemMessage(content="Ты — эксперт по кино и сериалам. Всегда основывайся на предоставленном контексте и не придумывай лишнего."),
-            HumanMessage(content=full_prompt)
-        ]).content.strip()
-        return response
+        return llm.invoke([SystemMessage(content="Ты — эксперт по кино и сериалам."),
+                            HumanMessage(content=f"Запрос: {user_query}\n\n{ctx}")]).content.strip()
     except Exception as e:
         return f"Ошибка при генерации ответа LLM: {e}"
 
-# --- UI: main ---
+# ====== UI: main ======
 def main():
-    st.set_page_config(page_title="🎬 Поиск фильмов и сериалов + Groq AI", layout="wide")
-    st.title("📽️ Семантический поиск фильмов и сериалов с AI")
+    st.set_page_config(page_title="Поиск фильмов и сериалов + AI", layout="wide")
+    st.title("Семантический поиск фильмов и сериалов с AI")
 
+    # ====== Инициализация данных и ресурсов один раз (через session_state) ======
     if "df" not in st.session_state:
-        st.session_state.df = cached_load_data(CSV_PATH)
+        try:
+            st.session_state.df = cached_load_data(CSV_PATH)
+        except FileNotFoundError as e:
+            st.error(str(e))
+            st.stop()
+        except Exception as e:
+            st.error(f"Не удалось загрузить данные: {e}")
+            st.stop()
+
     if "embedder" not in st.session_state:
-        st.session_state.embedder = cached_init_embedder()
+        try:
+            st.session_state.embedder = cached_init_embedder()
+        except Exception as e:
+            st.error(f"Ошибка инициализации embedder: {e}")
+            st.stop()
+
     if "embeddings_index" not in st.session_state:
-        with st.spinner("Загрузка эмбеддингов и индекса..."):
+        try:
             st.session_state.embeddings, st.session_state.index = cached_load_embeddings_and_index()
+        except FileNotFoundError as e:
+            st.error(str(e))
+            st.stop()
+        except Exception as e:
+            st.error(f"Ошибка загрузки индекса/эмбеддингов: {e}")
+            st.stop()
+
     if "llm" not in st.session_state:
-        st.session_state.llm = init_groq_llm()
+        # Инициализация LLM происходит только здесь, и результат сохраняется в session_state
+        st.session_state.llm = cached_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
 
-    with st.container():
-        st.markdown("---")
-        with st.form(key='search_form'):
-            colf1, colf2, colf3, colf4 = st.columns(4)
-            with colf1:
-                basic_genres_list = sorted(list(set(g.strip() for g in ", ".join(df["basic_genres"].dropna().unique()).split(","))))
-                genres = ["Все"] + [g for g in basic_genres_list if g]
-                genre_filter = st.selectbox("Жанр", genres, index=0, key="genre_filter_key")
-            with colf2:
-                years = ["Все"] + [str(y) for y in sorted(df["year"].unique()) if y != 0]
-                year_filter = st.selectbox("Год", years, index=0, key="year_filter_key")
-            with colf3:
-                countries = ["Все"] + sorted([c for c in df["country"].dropna().unique()])
-                country_filter = st.selectbox("Страна", countries, index=0, key="country_filter_key")
-            with colf4:
-                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")
-
-            col_buttons = st.columns(4)
-            with col_buttons[0]:
-                random_search = st.form_submit_button("🎲 Случайный фильм/сериал")
-            with col_buttons[1]:
-                genre_search = st.form_submit_button("🔥 ТОП по жанру")
-            with col_buttons[2]:
-                new_search = st.form_submit_button("🆕 Новинки")
-            with col_buttons[3]:
-                text_search = st.form_submit_button("🔍 Искать")
-
-    if text_search:
-        if not user_input.strip():
-            st.warning("Введите запрос для поиска.")
-        else:
-            st.session_state.last_query = user_input
+    # ====== Форма поиска (стабильная) ======
+    results_container = st.container()
+    ai_response_container = st.container()
+    
+    with st.form(key='search_form'):
+        colf1, colf2, colf3, colf4 = st.columns(4)
+        with colf1:
+            basic_genres_list = []
+            for g in df["basic_genres"].dropna().unique():
+                for part in str(g).split(","):
+                    p = part.strip()
+                    if p:
+                        basic_genres_list.append(p)
+            genres = ["Все"] + sorted(set(basic_genres_list))
+            genre_filter = st.selectbox("Жанр", genres, index=0, key="genre_filter_key")
+        with colf2:
+            years = ["Все"] + [str(y) for y in sorted(df["year"].unique()) if y != 0]
+            year_filter = st.selectbox("Год", years, index=0, key="year_filter_key")
+        with colf3:
+            countries = ["Все"] + sorted([c for c in df["country"].dropna().unique()])
+            country_filter = st.selectbox("Страна", countries, index=0, key="country_filter_key")
+        with colf4:
+            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")
+
+        nav1, nav2, nav3, nav4 = st.columns(4)
+        with nav1:
+            random_search = st.form_submit_button("Случайный фильм/сериал")
+        with nav2:
+            genre_search = st.form_submit_button("ТОП по жанру")
+        with nav3:
+            new_search = st.form_submit_button("Новинки")
+        with nav4:
+            text_search = st.form_submit_button("Искать")
+
+    performed_search = False
+    if text_search and user_input:
+        st.session_state.last_query = user_input
+        performed_search = True
+        with st.spinner("Поиск..."):
             st.session_state.results = semantic_search(
                 user_input, embedder, index, df,
                 genre_filter, year_filter, country_filter, type_filter, k
@@ -356,82 +275,81 @@ def main():
     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
-        )
-        st.session_state.ai_clicked = False
+        performed_search = True
+        with st.spinner("Поиск..."):
+            st.session_state.results = semantic_search(
+                random_query, embedder, index, df,
+                genre_filter, year_filter, country_filter, type_filter, k
+            )
+            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
-        )
-        st.session_state.ai_clicked = False
+        st.session_state.last_query = genre_filter
+        performed_search = True
+        with st.spinner("Поиск..."):
+            st.session_state.results = semantic_search(
+                genre_filter, embedder, index, df,
+                genre_filter, year_filter, country_filter, type_filter, k
+            )
+            st.session_state.ai_clicked = False
     elif new_search:
-        new_query = f"Самые новые фильмы и сериалы {df['year'].max()}"
+        new_query = str(int(df["year"].max())) if not df["year"].isna().all() else ""
         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
-        )
-        st.session_state.ai_clicked = False
-
-    results_container = st.container()
-    ai_response_container = st.container()
+        performed_search = True
+        with st.spinner("Поиск..."):
+            st.session_state.results = semantic_search(
+                new_query, embedder, index, df,
+                genre_filter, year_filter, country_filter, type_filter, k
+            )
+            st.session_state.ai_clicked = False
+    else: # Если ничего не нажато, но session_state пуст
+        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
 
     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}'.")
+            if performed_search and ('last_query' in st.session_state and st.session_state.last_query.strip() != ""):
+                st.warning("Ничего не найдено.")
             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():
-                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')):
+                card_cols = st.columns([1, 3])
+                with card_cols[0]:
+                    if row.get("image_url"):
                         try:
-                            st.image(image_url, width=150)
+                            st.image(row["image_url"], width=150)
                         except Exception:
-                            st.info("🤷‍♂️ Нет изображения.")
+                            st.info("Нет изображения")
                     else:
-                        st.info("🤷‍♂️ Нет изображения.")
-                with col2:
+                        st.info("Нет изображения")
+                with card_cols[1]:
                     st.markdown(f"### {row['tvshow_title']} ({row['year']})")
-                    st.caption(
-                        f"🎭 {row['basic_genres']} | 📍 {row['country'] or '—'}"
-                        f" | ⭐ {row['rating'] or '—'}"
-                        f" | 🎬 {row['type']} | 📺 {row['num_seasons']} сез."
-                    )
+                    st.caption(f"{row['basic_genres']} | {row['country'] or '—'} | {row['rating'] or '—'} | {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()
 
-    if st.session_state.llm and not st.session_state.results.empty:
-        if st.button("🧠 AI: почему эти подходят и что ещё посмотреть", key="ai_button"):
-            st.session_state.ai_clicked = True
+            if st.session_state.llm and 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:")
+        if st.session_state.get("ai_clicked") and results_exist:
+            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.markdown("---")
-    st.sidebar.markdown("## ℹ️ Информация")
-    st.sidebar.write(f"Всего записей в базе: {len(df)}")
-    st.sidebar.markdown(f"**Статус Groq LLM:** {'🟢 Готов' if llm else '🔴 Отключён (нужен API-ключ)'}")
+    st.sidebar.write(f"Всего записей: {len(df)}")
+    st.sidebar.markdown(f"**Статус LLM:** {'Готов' if llm else 'Отключён (нет API-ключа)'}")
 
 if __name__ == "__main__":
     main()