hope

.streamlit/config.toml

@@ -1,23 +0,0 @@
-[theme]
-base = "light"
-primaryColor = "#1f77b4"
-backgroundColor = "#ffffff"
-secondaryBackgroundColor = "#f0f2f6"
-textColor = "#262730"
-font = "sans serif"
-
-[server]
-# Important for HuggingFace Spaces
-enableCORS = false
-enableXsrfProtection = true
-maxUploadSize = 200
-headless = true
-
-[browser]
-# Prevent auto-reruns on HF Spaces
-gatherUsageStats = false
-
-[runner]
-# Optimize for production environments like HF Spaces
-magicEnabled = false
-fastReruns = true

README.md

@@ -1,19 +0,0 @@
----
-title: News TG Channel RAG
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

app.py

@@ -0,0 +1,429 @@
+"""
+Streamlit Frontend для RAG вопросно-ответной системы
+Чат-интерфейс с поддержкой нескольких диалогов
+"""
+import streamlit as st
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional
+import uuid
+
+from src import RAG
+from src.db_utils.history_utils import (
+    init_history_table,
+    log_query,
+    get_all_history,
+    get_history_by_dialogue,
+    search_history,
+    get_history_stats,
+    delete_history,
+    get_recent_dialogues
+)
+
+
+# --- Инициализация RAG и БД ---
+@st.cache_resource(show_spinner=False)
+def get_rag():
+    """Initialize RAG once and cache it"""
+    return RAG(
+        embed_model_name = "Qwen/Qwen3-Embedding-0.6B",
+        embed_index_name = "recursive_Qwen3-Embedding-0.6B"
+    )
+
+
+@st.cache_resource(show_spinner=False)
+def init_db():
+    """Initialize database once and cache it"""
+    try:
+        init_history_table()
+        return True
+    except Exception as e:
+        st.error(f"⚠️ Не удалось инициализировать таблицу истории: {e}")
+        return False
+
+
+# --- Session State Management ---
+def init_session_state():
+    """Initialize session state with caching"""
+    if "current_dialogue_id" not in st.session_state:
+        st.session_state.current_dialogue_id = None
+    if "chat_list" not in st.session_state:
+        st.session_state.chat_list = []
+    if "current_chat_messages" not in st.session_state:
+        st.session_state.current_chat_messages = []
+    if "chat_list_loaded" not in st.session_state:
+        st.session_state.chat_list_loaded = False
+
+
+def generate_dialogue_id() -> str:
+    """Generate unique dialogue ID"""
+    return f"chat_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:6]}"
+
+
+def get_chat_display_name(dialogue_id: str, first_query: str = None) -> str:
+    """Get display name for chat - always from DB, no caching"""
+    if first_query:
+        # Use first 40 chars of first query as name
+        name = first_query[:40] + "..." if len(first_query) > 40 else first_query
+        return name
+    
+    return "Новый диалог"
+
+
+# --- Chat Management Functions ---
+
+def load_chats_list():
+    """Load and cache chats list from DB"""
+    try:
+        st.session_state.chat_list = get_recent_dialogues(limit=50)
+        st.session_state.chat_list_loaded = True
+    except Exception as e:
+        st.error(f"❌ Ошибка при загрузке чатов: {e}")
+        st.session_state.chat_list = []
+
+
+def create_new_chat():
+    """Create a new chat"""
+    new_id = generate_dialogue_id()
+    st.session_state.current_dialogue_id = new_id
+    st.session_state.current_chat_messages = []
+    st.session_state.needs_rerun = True
+    return new_id
+
+
+def switch_to_chat(dialogue_id: str):
+    """Switch to an existing chat and load its messages"""
+    st.session_state.current_dialogue_id = dialogue_id
+    load_current_chat_messages()
+    st.session_state.needs_rerun = True
+
+
+def load_current_chat_messages():
+    """Load messages for current chat from DB and cache"""
+    if not st.session_state.current_dialogue_id:
+        st.session_state.current_chat_messages = []
+        return
+    
+    try:
+        st.session_state.current_chat_messages = get_history_by_dialogue(
+            st.session_state.current_dialogue_id
+        )
+    except Exception as e:
+        st.error(f"❌ Ошибка при загрузке сообщений: {e}")
+        st.session_state.current_chat_messages = []
+
+
+def get_current_chat_messages() -> List[Dict]:
+    """Get cached messages for current chat"""
+    return st.session_state.current_chat_messages
+
+
+def send_message(query: str) -> Optional[Dict]:
+    """Send a message in current chat and update cache"""
+    try:
+        if not st.session_state.current_dialogue_id:
+            create_new_chat()
+        
+        # Get RAG and invoke with cached history
+        rag = get_rag()
+        
+        # Use cached messages
+        current_history = get_current_chat_messages()
+        
+        # Pass history to RAG (it will use last N messages internally for enrichment)
+        result = rag.invoke(query, history=current_history)
+        
+        # Log to history DB
+        query_id = log_query(
+            query=query,
+            answer=result.get("answer", ""),
+            reason=result.get("reason", ""),
+            dialogue_id=st.session_state.current_dialogue_id
+        )
+        
+        result["query_id"] = query_id
+        
+        # Update only current messages, not all chats
+        load_current_chat_messages()
+        
+        # Mark that we need to refresh chat list (but don't do it immediately)
+        st.session_state.chat_list_loaded = False
+        st.session_state.needs_rerun = True
+        
+        return result
+    except Exception as e:
+        st.error(f"❌ Ошибка при отправке сообщения: {e}")
+        return None
+
+
+def delete_chat(dialogue_id: str) -> bool:
+    """Delete a chat from DB and update cache"""
+    try:
+        delete_history(dialogue_id=dialogue_id)
+        
+        # If deleted current chat, clear selection
+        if st.session_state.current_dialogue_id == dialogue_id:
+            st.session_state.current_dialogue_id = None
+            st.session_state.current_chat_messages = []
+        
+        # Mark that we need to reload chat list
+        st.session_state.chat_list_loaded = False
+        st.session_state.needs_rerun = True
+        
+        return True
+    except Exception as e:
+        st.error(f"❌ Ошибка при удалении чата: {e}")
+        return False
+
+
+
+
+# --- Page: Chat Interface ---
+def page_chat():
+    """Main chat interface page"""
+    
+    # Custom CSS to fix chat input at the bottom + keyboard shortcuts
+    st.markdown("""
+        <style>
+        /* Fix chat input at the bottom of main content area */
+        section[data-testid="stSidebar"] ~ div .stChatInput {
+            position: fixed;
+            bottom: 0;
+            background: white;
+            padding: 1rem;
+            z-index: 999;
+            border-top: 1px solid #e6e6e6;
+            margin-left: 0;
+        }
+        
+        /* Add padding to main content to prevent overlap with fixed input */
+        .main .block-container {
+            padding-bottom: 100px;
+        }
+        
+        /* Dark mode support */
+        [data-testid="stAppViewContainer"][data-theme="dark"] section[data-testid="stSidebar"] ~ div .stChatInput {
+            background: rgb(14, 17, 23);
+            border-top: 1px solid #333;
+        }
+        
+        /* Adjust width to account for sidebar */
+        @media (min-width: 768px) {
+            section[data-testid="stSidebar"] ~ div .stChatInput {
+                left: var(--sidebar-width, 21rem);
+                right: 0;
+            }
+        }
+        
+        /* When sidebar is collapsed */
+        section[data-testid="stSidebar"][aria-expanded="false"] ~ div .stChatInput {
+            left: 0;
+        }
+        </style>
+        
+        <script>
+        // Add keyboard shortcuts support
+        document.addEventListener('DOMContentLoaded', function() {
+            // Find chat input field
+            const observer = new MutationObserver(function(mutations) {
+                const chatInput = document.querySelector('textarea[data-testid="stChatInput"]');
+                if (chatInput && !chatInput.hasAttribute('data-shortcut-attached')) {
+                    chatInput.setAttribute('data-shortcut-attached', 'true');
+                    
+                    // Add keyboard event listener
+                    chatInput.addEventListener('keydown', function(e) {
+                        // Enter (without Shift) - send message
+                        if (e.key === 'Enter' && !e.shiftKey) {
+                            e.preventDefault();
+                            // Trigger the send button
+                            const sendButton = document.querySelector('button[kind="primary"]');
+                            if (sendButton) {
+                                sendButton.click();
+                            }
+                        }
+                        // Ctrl+Enter or Cmd+Enter - send message (alternative)
+                        else if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
+                            e.preventDefault();
+                            const sendButton = document.querySelector('button[kind="primary"]');
+                            if (sendButton) {
+                                sendButton.click();
+                            }
+                        }
+                        // Shift+Enter - new line (default behavior)
+                    });
+                }
+            });
+            
+            observer.observe(document.body, {
+                childList: true,
+                subtree: true
+            });
+        });
+        </script>
+    """, unsafe_allow_html=True)
+    
+    # Check if we have a current chat
+    if not st.session_state.current_dialogue_id:
+        # Show welcome screen
+        st.title("💬 Чат с RAG системой")
+        st.markdown("---")
+        
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            st.info("👋 Добро пожаловать! Создайте новый чат или выберите существующий из списка слева.")
+            
+            if st.button("🆕 Начать новый чат", type="primary", use_container_width=True):
+                create_new_chat()
+        
+        return
+    
+    # Get cached messages
+    current_messages = get_current_chat_messages()
+    
+    # Display chat header
+    if current_messages:
+        chat_name = get_chat_display_name(
+            st.session_state.current_dialogue_id,
+            current_messages[0]["query"]
+        )
+    else:
+        chat_name = "Новый диалог"
+    
+    col1, col2 = st.columns([4, 1])
+    with col1:
+        st.title(f"💬 {chat_name}")
+    with col2:
+        if st.button("🗑️ Удалить чат", use_container_width=True):
+            if delete_chat(st.session_state.current_dialogue_id):
+                st.success("✅ Чат удален")
+    
+    st.markdown("---")
+    
+    # Chat messages container - load from DB
+    if not current_messages:
+        st.info("📝 Начните диалог, задав первый вопрос ниже")
+    else:
+        # Display all messages
+        for msg in current_messages:
+            # User message
+            with st.chat_message("user"):
+                st.markdown(msg["query"])
+                timestamp_str = msg.get("timestamp", "")
+                try:
+                    dt = datetime.fromisoformat(timestamp_str)
+                    st.caption(f"🕐 {dt.strftime('%H:%M:%S')}")
+                except:
+                    pass
+            
+            # Assistant message
+            with st.chat_message("assistant"):
+                st.markdown(msg["answer"])
+                
+                # Show reasoning in expander
+                if msg.get("reason"):
+                    with st.expander("📝 Обоснование"):
+                        st.markdown(msg["reason"])
+    
+    # Input area - fixed at the bottom via CSS
+    query = st.chat_input(
+        "Введите ваш вопрос...",
+        key="chat_input"
+    )
+    
+    if query:
+        # Send message and get response
+        with st.spinner("🤔 Думаю..."):
+            result = send_message(query)
+
+
+
+# --- Main App ---
+def main():
+    st.set_page_config(
+        page_title="RAG Chat System",
+        page_icon="💬",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Initialize session state FIRST (before any other operations)
+    init_session_state()
+    
+    # Initialize needs_rerun flag if not exists
+    if "needs_rerun" not in st.session_state:
+        st.session_state.needs_rerun = False
+    
+    # Initialize history table once using cache
+    init_db()
+    
+    # Load chats list if not loaded yet
+    if not st.session_state.chat_list_loaded:
+        load_chats_list()
+    
+    # Sidebar
+    with st.sidebar:
+        st.title("💬 RAG Chat")
+        
+        # New chat button
+        if st.button("➕ Новый чат", use_container_width=True, type="primary"):
+            create_new_chat()
+        
+        st.markdown("---")
+        
+        # Chats list - use cached
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            st.subheader("📝 Ваши чаты")
+        with col2:
+            if st.button("🔄", help="Обновить список чатов"):
+                st.session_state.chat_list_loaded = False
+                load_chats_list()
+        
+        if not st.session_state.chat_list:
+            st.info("Нет чатов. Создайте новый!")
+        else:
+            # Display chats from cache
+            for chat in st.session_state.chat_list:
+                dialogue_id = chat["dialogue_id"]
+                message_count = chat.get("message_count", 0)
+                started_at = chat.get("started_at", "")
+                
+                # Get chat name (only load history if chat has messages)
+                if message_count > 0:
+                    history = get_history_by_dialogue(dialogue_id)
+                    first_query = history[0]["query"] if history else None
+                else:
+                    first_query = None
+                chat_name = get_chat_display_name(dialogue_id, first_query)
+                
+                # Format time
+                try:
+                    dt = datetime.fromisoformat(started_at)
+                    time_str = dt.strftime('%d.%m %H:%M')
+                except:
+                    time_str = ""
+                
+                # Check if this is current chat
+                is_current = dialogue_id == st.session_state.current_dialogue_id
+                
+                # Format button text with chat name and metadata
+                button_text = f"{'📌' if is_current else '💬'} {chat_name}\n💬 {message_count} • {time_str}"
+                
+                if st.button(
+                    button_text,
+                    key=f"chat_{dialogue_id}",
+                    use_container_width=True,
+                    type="primary" if is_current else "secondary"
+                ):
+                    switch_to_chat(dialogue_id)
+    
+    # Handle rerun at the end if needed
+    if st.session_state.needs_rerun:
+        st.session_state.needs_rerun = False
+        st.rerun()
+    
+    # Main content area
+    page_chat()
+
+
+if __name__ == "__main__":
+    main()

frontend.py

@@ -20,7 +20,7 @@ from src.db_utils.history_utils import (
 )
 
 
-# --- Инициализация RAG и БД ---
+# --- Инициализация RAG ---
 @st.cache_resource(show_spinner=False)
 def get_rag():
     """Initialize RAG once and cache it"""
@@ -30,28 +30,19 @@ def get_rag():
     )
 
 
-@st.cache_resource(show_spinner=False)
-def init_db():
-    """Initialize database once and cache it"""
-    try:
-        init_history_table()
-        return True
-    except Exception as e:
-        st.error(f"⚠️ Не удалось инициализировать таблицу истории: {e}")
-        return False
-
-
 # --- Session State Management ---
 def init_session_state():
-    """Initialize session state with caching"""
+    """Initialize session state variables for chat support"""
     if "current_dialogue_id" not in st.session_state:
         st.session_state.current_dialogue_id = None
     if "chat_list" not in st.session_state:
         st.session_state.chat_list = []
     if "current_chat_messages" not in st.session_state:
         st.session_state.current_chat_messages = []
-    if "chat_list_loaded" not in st.session_state:
-        st.session_state.chat_list_loaded = False
+    if "chat_names" not in st.session_state:
+        st.session_state.chat_names = {}  # {dialogue_id: custom_name}
+    if "chats_loaded" not in st.session_state:
+        st.session_state.chats_loaded = False
 
 
 def generate_dialogue_id() -> str:
@@ -60,10 +51,14 @@ def generate_dialogue_id() -> str:
 
 
 def get_chat_display_name(dialogue_id: str, first_query: str = None) -> str:
-    """Get display name for chat - always from DB, no caching"""
+    """Get display name for chat"""
+    if dialogue_id in st.session_state.chat_names:
+        return st.session_state.chat_names[dialogue_id]
+    
     if first_query:
         # Use first 40 chars of first query as name
         name = first_query[:40] + "..." if len(first_query) > 40 else first_query
+        st.session_state.chat_names[dialogue_id] = name
         return name
     
     return "Новый диалог"
@@ -72,10 +67,15 @@ def get_chat_display_name(dialogue_id: str, first_query: str = None) -> str:
 # --- Chat Management Functions ---
 
 def load_chats_list():
-    """Load and cache chats list from DB"""
+    """Load all available chats from database"""
     try:
-        st.session_state.chat_list = get_recent_dialogues(limit=50)
-        st.session_state.chat_list_loaded = True
+        dialogues = get_recent_dialogues(limit=50)
+        st.session_state.chat_list = dialogues
+        st.session_state.chats_loaded = True
+        
+        # If no current chat selected and chats exist, select the first one
+        if not st.session_state.current_dialogue_id and dialogues:
+            switch_to_chat(dialogues[0]["dialogue_id"])
     except Exception as e:
         st.error(f"❌ Ошибка при загрузке чатов: {e}")
         st.session_state.chat_list = []
@@ -86,53 +86,38 @@ def create_new_chat():
     new_id = generate_dialogue_id()
     st.session_state.current_dialogue_id = new_id
     st.session_state.current_chat_messages = []
-    st.session_state.needs_rerun = True
     return new_id
 
 
 def switch_to_chat(dialogue_id: str):
-    """Switch to an existing chat and load its messages"""
+    """Switch to an existing chat"""
     st.session_state.current_dialogue_id = dialogue_id
-    load_current_chat_messages()
-    st.session_state.needs_rerun = True
+    load_chat_messages(dialogue_id)
 
 
-def load_current_chat_messages():
-    """Load messages for current chat from DB and cache"""
-    if not st.session_state.current_dialogue_id:
-        st.session_state.current_chat_messages = []
-        return
-    
+def load_chat_messages(dialogue_id: str):
+    """Load messages for a specific chat"""
     try:
-        st.session_state.current_chat_messages = get_history_by_dialogue(
-            st.session_state.current_dialogue_id
-        )
+        history = get_history_by_dialogue(dialogue_id)
+        st.session_state.current_chat_messages = history
     except Exception as e:
         st.error(f"❌ Ошибка при загрузке сообщений: {e}")
         st.session_state.current_chat_messages = []
 
 
-def get_current_chat_messages() -> List[Dict]:
-    """Get cached messages for current chat"""
-    return st.session_state.current_chat_messages
-
-
 def send_message(query: str) -> Optional[Dict]:
-    """Send a message in current chat and update cache"""
+    """Send a message in current chat"""
     try:
         if not st.session_state.current_dialogue_id:
             create_new_chat()
         
-        # Get RAG and invoke with cached history
+        # Get RAG and invoke with history
         rag = get_rag()
         
-        # Use cached messages
-        current_history = get_current_chat_messages()
+        # Pass current chat history to RAG (it will use last N messages internally for enrichment)
+        result = rag.invoke(query, history=st.session_state.current_chat_messages)
         
-        # Pass history to RAG (it will use last N messages internally for enrichment)
-        result = rag.invoke(query, history=current_history)
-        
-        # Log to history DB
+        # Log to history
         query_id = log_query(
             query=query,
             answer=result.get("answer", ""),
@@ -142,12 +127,11 @@ def send_message(query: str) -> Optional[Dict]:
         
         result["query_id"] = query_id
         
-        # Update only current messages, not all chats
-        load_current_chat_messages()
+        # Update current chat messages
+        load_chat_messages(st.session_state.current_dialogue_id)
         
-        # Mark that we need to refresh chat list (but don't do it immediately)
-        st.session_state.chat_list_loaded = False
-        st.session_state.needs_rerun = True
+        # Reload chats list to update
+        load_chats_list()
         
         return result
     except Exception as e:
@@ -156,18 +140,17 @@ def send_message(query: str) -> Optional[Dict]:
 
 
 def delete_chat(dialogue_id: str) -> bool:
-    """Delete a chat from DB and update cache"""
+    """Delete a chat"""
     try:
         delete_history(dialogue_id=dialogue_id)
         
-        # If deleted current chat, clear selection
+        # If deleted current chat, switch to another or create new
         if st.session_state.current_dialogue_id == dialogue_id:
             st.session_state.current_dialogue_id = None
             st.session_state.current_chat_messages = []
         
-        # Mark that we need to reload chat list
-        st.session_state.chat_list_loaded = False
-        st.session_state.needs_rerun = True
+        # Reload chats
+        load_chats_list()
         
         return True
     except Exception as e:
@@ -273,17 +256,15 @@ def page_chat():
             
             if st.button("🆕 Начать новый чат", type="primary", use_container_width=True):
                 create_new_chat()
+                st.rerun()
         
         return
     
-    # Get cached messages
-    current_messages = get_current_chat_messages()
-    
     # Display chat header
-    if current_messages:
+    if st.session_state.current_chat_messages:
         chat_name = get_chat_display_name(
             st.session_state.current_dialogue_id,
-            current_messages[0]["query"]
+            st.session_state.current_chat_messages[0]["query"]
         )
     else:
         chat_name = "Новый диалог"
@@ -295,15 +276,16 @@ def page_chat():
         if st.button("🗑️ Удалить чат", use_container_width=True):
             if delete_chat(st.session_state.current_dialogue_id):
                 st.success("✅ Чат удален")
+                st.rerun()
     
     st.markdown("---")
     
-    # Chat messages container - load from DB
-    if not current_messages:
+    # Chat messages container
+    if not st.session_state.current_chat_messages:
         st.info("📝 Начните диалог, задав первый вопрос ниже")
     else:
         # Display all messages
-        for msg in current_messages:
+        for msg in st.session_state.current_chat_messages:
             # User message
             with st.chat_message("user"):
                 st.markdown(msg["query"])
@@ -333,6 +315,9 @@ def page_chat():
         # Send message and get response
         with st.spinner("🤔 Думаю..."):
             result = send_message(query)
+            
+            if result:
+                st.rerun()
 
 
 
@@ -345,18 +330,17 @@ def main():
         initial_sidebar_state="expanded"
     )
     
-    # Initialize session state FIRST (before any other operations)
-    init_session_state()
-    
-    # Initialize needs_rerun flag if not exists
-    if "needs_rerun" not in st.session_state:
-        st.session_state.needs_rerun = False
+    # Initialize history table on startup
+    try:
+        init_history_table()
+    except Exception as e:
+        st.error(f"⚠️ Не удалось инициализировать таблицу истории: {e}")
     
-    # Initialize history table once using cache
-    init_db()
+    # Initialize session state
+    init_session_state()
     
-    # Load chats list if not loaded yet
-    if not st.session_state.chat_list_loaded:
+    # Load chats list if not loaded
+    if not st.session_state.chats_loaded:
         load_chats_list()
     
     # Sidebar
@@ -366,22 +350,17 @@ def main():
         # New chat button
         if st.button("➕ Новый чат", use_container_width=True, type="primary"):
             create_new_chat()
+            st.rerun()
         
         st.markdown("---")
         
-        # Chats list - use cached
-        col1, col2 = st.columns([3, 1])
-        with col1:
-            st.subheader("📝 Ваши чаты")
-        with col2:
-            if st.button("🔄", help="Обновить список чатов"):
-                st.session_state.chat_list_loaded = False
-                load_chats_list()
+        # Chats list
+        st.subheader("📝 Ваши чаты")
         
         if not st.session_state.chat_list:
             st.info("Нет чатов. Создайте новый!")
         else:
-            # Display chats from cache
+            # Display chats
             for chat in st.session_state.chat_list:
                 dialogue_id = chat["dialogue_id"]
                 message_count = chat.get("message_count", 0)
@@ -415,11 +394,7 @@ def main():
                     type="primary" if is_current else "secondary"
                 ):
                     switch_to_chat(dialogue_id)
-    
-    # Handle rerun at the end if needed
-    if st.session_state.needs_rerun:
-        st.session_state.needs_rerun = False
-        st.rerun()
+                    st.rerun()
     
     # Main content area
     page_chat()

requirements.txt

@@ -1,4 +1,5 @@
 pandas==2.3.3
+python-dotenv==1.2.1
 pyaes==1.6.1
 Pyrogram==2.0.106
 PySocks==1.7.1
@@ -24,6 +25,8 @@ langchain-openai==1.0.0
 sqlalchemy==2.0.44
 psycopg2-binary==2.9.11
 qdrant-client==1.16.2
+fastapi==0.124.4
+uvicorn==0.38.0
 openai==1.109.1
 pydantic==2.9.2
 tenacity==9.0.0

server.py

@@ -46,7 +46,8 @@ rag = RAG(
 
 class QueryRequest(BaseModel):
     query: str
-    dialogue_id: Optional[str] = None  # Для будущей поддержки диалогов
+    dialogue_id: Optional[str] = None
+    history: Optional[List[Dict[str, Any]]] = None  # История диалога для контекста
 
 
 class QueryResponse(BaseModel):
@@ -86,8 +87,15 @@ class DialogueInfo(BaseModel):
 def rag_query(request: QueryRequest):
     """Основной endpoint для запросов к RAG. Логирует запрос после получения ответа."""
 
-    # Получаем ответ от RAG
-    result = rag.invoke(request.query)
+    # Если передан dialogue_id, загружаем историю
+    history = None
+    if request.dialogue_id and not request.history:
+        history = get_history_by_dialogue(request.dialogue_id)
+    elif request.history:
+        history = request.history
+    
+    # Получаем ответ от RAG с историей (история используется для обогащения вопроса)
+    result = rag.invoke(request.query, history=history)
     
     # Логируем в историю
     query_id = log_query(

src/parser/pyrosource.py

@@ -1,64 +0,0 @@
-import time 
-from typing import Union, Generator, List, Dict, Any
-
-from pyrogram import Client
-from pyrogram.types import Message
-
-
-class PyroSource:
-
-    def __init__(
-            self, 
-            api_id: Union[int, str], 
-            api_hash: str, 
-            app_name: str = "default_app",
-        ):
-        self.client = Client(name=app_name, api_id=api_id, api_hash=api_hash)
-
-    
-    def load_messages(
-        self, 
-        channel_id: Union[int, str], 
-        limit: int, 
-        offset: int = 0, 
-        offset_id: int = 0,
-        time_sleep: float = 0.05,
-    ) -> List[Dict[str, Any]]:
-        """
-        channel_id: channel id or username
-        limit: number of messages to load
-        offset: offset index
-        offset_id: message id offset
-        """
-        posts = []
-
-        with self.client as app:
-            messages: Generator[Message] = app.get_chat_history(
-                chat_id=channel_id, 
-                limit=limit, 
-                offset=offset, 
-                offset_id=offset_id,
-            )
-
-            for msg in messages:
-                time.sleep(time_sleep)
-
-                content = msg.text or msg.caption or ''
-                original_author = (
-                    msg.forward_from_chat.username if msg.forward_from_chat else ''
-                )
-                message_dt = msg.date.strftime("%Y-%m-%d")
-
-
-                meta = {
-                    "message_dt" : message_dt,
-                    "message_id" : msg.id,
-                    "channel_id" : channel_id,
-                    "content" : content,
-                    "views" : msg.views,
-                    "original_author" : original_author,
-                }
-
-                posts.append(meta)
-        
-        return posts

src/parser/run_loader.py

@@ -1,62 +0,0 @@
-import os
-import argparse
-
-from structlog import get_logger
-import pandas as pd
-
-from src.config import pyro_source
-
-
-BATCH_SIZE = 256
-logger = get_logger()
-
-
-def save_batch(df: pd.DataFrame, out_path: str, is_first_batch: bool):
-    if is_first_batch:
-        df.to_csv(out_path, index=False, mode="w")
-    else:
-        df.to_csv(out_path, index=False, mode="a", header=False)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Telegram posts loader")
-
-    parser.add_argument("--channel_id", type=str, required=True)
-    parser.add_argument("--limit", type=int, required=True)
-    parser.add_argument("--offset", type=int, default=0)
-
-    args = parser.parse_args()
-    total_limit = args.limit
-    channel_id = args.channel_id
-    base_offset = args.offset
-    
-
-    out_path = f"./channel_{channel_id}_posts.csv"
-    is_first_batch = not os.path.exists(out_path)
-
-
-    total_batches = (total_limit + BATCH_SIZE - 1) // BATCH_SIZE
-
-    for batch_num in range(total_batches):
-        logger.info(f"Batch #{batch_num} loading")
-
-        current_offset = base_offset + batch_num * BATCH_SIZE
-
-        posts = pyro_source.load_messages(
-            channel_id=channel_id,
-            limit=BATCH_SIZE,
-            offset=current_offset
-        )
-
-        df = pd.DataFrame(posts)
-        save_batch(df, out_path, is_first_batch)
-        is_first_batch = False
-
-
-    logger.info("Finished loading")
-
-
-
-
-if __name__ == "__main__":
-    main()

src/rag/rag.py

@@ -26,6 +26,19 @@ class RAG:
         self.llm = get_model(LLM_API_KEY, LLM)
         self.history_length = CHAT_HISTORY_LENGTH
         self.enable_enrichment = ENABLE_QUESTION_ENRICHMENT
+
+        self.prompt = ChatPromptTemplate.from_messages([
+            SystemMessagePromptTemplate.from_template(
+                "Ты полезный и точный ассистент. "
+                "Ответь на вопрос, опираясь ТОЛЬКО на предложенный контекст. "
+                "Если в контексте нет ответа, ответь \"Не знаю.\""
+            ),
+            HumanMessagePromptTemplate.from_template(
+                "{format_instructions}\n\n"
+                "Контекст:\n{context}\n\n"
+                "Вопрос: {question}"
+            ),
+        ])
         
         # Initialize question enricher if enabled
         if self.enable_enrichment:
@@ -53,23 +66,9 @@ class RAG:
             # Get context from retriever using enriched query
             context = self.retriever.chain.invoke(enriched_query)
             
-            # Build prompt without history (enriched question already contains context)
-            prompt = ChatPromptTemplate.from_messages([
-                SystemMessagePromptTemplate.from_template(
-                    "Ты полезный и точный ассистент. "
-                    "Ответь на вопрос, опираясь ТОЛЬКО на предложенный контекст. "
-                    "Если в контексте нет ответа, ответь \"Не знаю.\""
-                ),
-                HumanMessagePromptTemplate.from_template(
-                    "{format_instructions}\n\n"
-                    "Контекст:\n{context}\n\n"
-                    "Вопрос: {question}"
-                ),
-            ])
-            
             # Build chain
             chain = (
-                prompt
+                self.prompt
                 | self.llm
                 | self.parser
             )

src/scripts/1_load_texts.py

@@ -1,84 +0,0 @@
-import pandas as pd
-
-from src.db_utils.sql_utils import sql_drop, sql_dump_df
-
-
-
-def strip_edges_allow_punct(s: str):
-    allowed_punct = set(".,!?;:-–—")  # можно расширять
-
-    # Левый указатель — пока не буква/цифра
-    left = 0
-    while left < len(s) and not s[left].isalnum():
-        left += 1
-
-    # Правый указатель — пока не буква/цифра/пунктуация
-    right = len(s) - 1
-    while right >= 0 and not (s[right].isalnum() or s[right] in allowed_punct):
-        right -= 1
-
-    # Если всё мусор
-    if right < left:
-        return ""
-
-    return s[left:right+1]
-
-
-def process_str(s: str):
-    # Чистка статьи от мусора
-    s = "\n".join(strip_edges_allow_punct(p) for p in s.split("\n") if p)
-    
-    for suf in [
-        "Слушать прямой эфир",
-        "Читать РБК Стиль в Telegram",
-        "РБК Events, 18",
-        "Подписаться | Онлайн-сомелье",
-        "Читать РБК в Telegram",
-        "Следить за новостями РБК в Telegram",
-        "Следить за новостями РБК в МАХ",
-        "Другие видео этого дня — в телеграм-канале РБК",
-        "РБК в Telegram и MAX",
-        "РБК в Telegram | MAX",
-        "Подписаться на «РБК Спорт",
-        "Картина дня — в телеграм-канале РБК",
-        "Самые важные новости — в канале РБК в МАХ",
-        "Больше инфографики — в телеграм-канале РБК",
-        "Подписаться на «Сам ты инвестор!",
-        "Читать РБК Недвижимость в Telegram"
-    ]:
-        s = s.removesuffix(suf).strip()
-
-    parts = [p for p in s.split("\n") if p]
-    
-    prev_parts = [0] * 1000
-    while len(prev_parts) != len(parts) and len(parts) != 0:
-        prev_parts = parts
-        if "Фото:" in parts[-1] or "Данные:" in parts[-1]:
-            parts = parts[:-1]
-    
-    return "\n".join(parts)
-
-
-def is_advertisement(s: str):
-    # Проверка рекламных объявлений
-    last_part = [p for p in s.split("\n") if p][-1]
-    return any(v in last_part for v in ["Реклама.", "Реклама,"])
-
-
-
-
-if __name__ == "__main__":
-    # Предобработка документов
-    rbc = pd.read_csv("src/dataset/rbc/channel_rbc_news_posts.csv")
-    
-    rbc["message_dt"] = pd.to_datetime(rbc["message_dt"]).dt.date
-    rbc["content"] = rbc["content"].apply(lambda x: process_str(x))
-    rbc["views"] = rbc["views"].astype(int)
-
-    rbc = rbc[~rbc["content"].apply(is_advertisement)]
-    rbc = rbc[["message_id", "channel_id", "message_dt", "views", "content"]]
-
-    # Загрузка в бд
-    table = "posts"
-    sql_drop(table)
-    sql_dump_df(rbc, table)

src/scripts/2_load_vectors.py

@@ -1,51 +0,0 @@
-import time
-
-import pandas as pd
-from langchain_huggingface.embeddings import HuggingFaceEmbeddings
-
-from src.db_utils.sql_utils import sql_fetch_batch
-from src.db_utils.qdrant_utils import qdrant_insert, qdrant_create_index
-from src.data.splitter import Splitter
-
-
-
-
-if __name__ == "__main__":
-    splitter_mode = "recursive"
-    model_name = "deepvk/USER-bge-m3"
-    vector_index_name = f"{splitter_mode}_{model_name.split('/')[1]}"
-
-    # Инициализация объектов
-    splitter = Splitter(splitter_mode, chunk_size=256, chunk_overlap=64)
-    emb = HuggingFaceEmbeddings(
-        model_name=model_name, 
-        encode_kwargs={"normalize_embeddings": True},
-    )
-
-    # Создание индекса
-    qdrant_create_index(
-        index_name=vector_index_name,
-        dim=len(emb.embed_documents(["None"])[0]),
-        distance="cosine",
-    )
-
-    # Загрузка документов батчами
-    batch_size = 16
-    offset = 0
-    while True:
-        rows = sql_fetch_batch(batch_size=batch_size, offset=offset)
-        if not rows:
-            break  # дошли до конца
-        
-        dfs = []
-        for r in rows:
-            chunks = splitter.split_text(r["content"])
-            vectors = emb.embed_documents(chunks)
-
-            dfs.append(pd.DataFrame({"doc_id": r["ctid"], "text": chunks, "vector": vectors}))
-        
-        print(f"{offset} - {offset + batch_size}:", qdrant_insert(pd.concat(dfs), vector_index_name))
-        
-        offset += batch_size
-
-        time.sleep(0.3)