Update app.py

app.py

@@ -1,4 +1,4 @@
-from flask import Flask, render_template, request, Response, jsonify, session
+from flask import Flask, render_template, request, Response, jsonify, make_response
 from mistralai import Mistral
 import logging
 import time
@@ -11,21 +11,65 @@ import os
 import trafilatura
 from bs4 import BeautifulSoup
 import random
+from uuid import uuid4
 
 app = Flask(__name__)
 app.secret_key = 'super_secret_key'
-app.config['SESSION_TYPE'] = 'filesystem'
-
 message_queue = queue.Queue()
 
+# Добавляем хранилище для диалогов
+conversations = {}
+MAX_CONVERSATION_LENGTH = 10  # Максимальная длина истории диалога
+
+class Conversation:
+    def __init__(self):
+        self.history = []
+        self.last_sources = []
+        self.last_search_query = ""
+        self.last_problem = ""
+        self.last_norm_data = {}
+        self.last_full_response = ""
+        self.timestamp = time.time()
+        
+    def add_exchange(self, user_message, bot_response, sources=None, 
+                    search_query=None, problem=None, norm_data=None, full_response=None):
+        self.history.append({
+            "user": user_message,
+            "bot": bot_response
+        })
+        self.timestamp = time.time()
+        
+        if sources is not None:
+            self.last_sources = sources
+        if search_query is not None:
+            self.last_search_query = search_query
+        if problem is not None:
+            self.last_problem = problem
+        if norm_data is not None:
+            self.last_norm_data = norm_data
+        if full_response is not None:
+            self.last_full_response = full_response
+            
+        # Ограничиваем длину истории
+        if len(self.history) > MAX_CONVERSATION_LENGTH:
+            self.history.pop(0)
+            
+    def get_context(self):
+        """Возвращает контекст предыдущего диалога в читаемом формате"""
+        context = f"Предыдущая проблема: {self.last_problem}\n\n"
+        context += f"Последний ответ системы:\n{self.last_full_response}\n\n"
+        context += "Источники информации:\n"
+        for i, source in enumerate(self.last_sources[:3]):  # Ограничиваем количество источников в контексте
+            context += f"[{i+1}] {source['title'][:50]}... - {source['url']}\n"
+        return context
+
 # Конфигурация Mistral
 MISTRAL_MODEL = "mistral-large-latest"
 N_CTX = 32768
 MAX_RESULTS = 5
-MAX_CONTENT_LENGTH = 10000
-MAX_HISTORY_LENGTH = 5  # Максимальное количество сообщений в истории
+MAX_CONTENT_LENGTH = 10000  # Максимальная длина контента на источник
 
-# Клиент Mistral
+# Новый клиент Mistral
 mistral_client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
 
 SYSTEM_PROMPT = """
@@ -49,14 +93,6 @@ SYSTEM_PROMPT = """
 6. Будь лаконичен, но технически точен
 """
 
-SYSTEM_PROMPT_CONTINUE = """
-Ты PrintMaster, сервисный инженер. Продолжаешь диалог с пользователем. Правила:
-1. Отвечай на основе предыдущего контекста диалога
-2. Будь лаконичным и технически точным
-3. Если вопрос не связан с предыдущей проблемой, вежливо предложи начать новый диалог
-4. Сохраняй профессиональный стиль общения
-"""
-
 BLACKLISTED_DOMAINS = [
     'reddit.com',
     'stackoverflow.com',
@@ -76,7 +112,7 @@ USER_AGENTS = [
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
     "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15"
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15"
 ]
 
 logging.basicConfig(
@@ -100,26 +136,29 @@ def get_random_headers():
     }
 
 def extract_main_content(html, url):
-    """Извлекает основной контент страницы"""
+    """Извлекает основной контент страницы с помощью trafilatura или BeautifulSoup"""
     try:
+        # Пробуем trafilatura
         content = trafilatura.extract(html, include_links=False, include_tables=False)
         if content and len(content) > 500:
             return content[:MAX_CONTENT_LENGTH]
     except Exception as e:
         logging.error(f"Trafilatura error: {str(e)}")
     
+    # Fallback на BeautifulSoup
     try:
         soup = BeautifulSoup(html, 'html.parser')
-        
+        # Удаляем ненужные элементы
         for element in soup(['script', 'style', 'header', 'footer', 'nav', 'aside', 'form']):
             element.decompose()
         
+        # Пытаемся найти основной контент
         main_content = soup.find('main') or soup.find('article') or soup.find('div', class_=re.compile('content|main|article|post', re.I))
-        
         if main_content:
             text = main_content.get_text(separator='\n', strip=True)
             return text[:MAX_CONTENT_LENGTH] if text else None
         
+        # Fallback: весь текст body
         return soup.body.get_text(separator='\n', strip=True)[:MAX_CONTENT_LENGTH]
     except Exception as e:
         logging.error(f"BeautifulSoup error: {str(e)}")
@@ -134,7 +173,6 @@ def generate_search_query(prompt: str) -> dict:
     - error_code: error code (if present)
     - problem_description: brief English problem description (1-2 sentences)
     - search_query: full English search query
-    
     Important rules:
     1. All fields MUST be in English
     2. For brands use official English names
@@ -142,7 +180,6 @@ def generate_search_query(prompt: str) -> dict:
     4. If error code is specified - include it in search_query
     5. Problem description should be concise technical terms (max 7 words)
     """
-    
     try:
         response = mistral_client.chat.complete(
             model=MISTRAL_MODEL,
@@ -154,9 +191,7 @@ def generate_search_query(prompt: str) -> dict:
             max_tokens=350,
             response_format={"type": "json_object"}
         )
-
         json_data = json.loads(response.choices[0].message.content)
-        
         required_fields = ['brand', 'model', 'error_code', 'problem_description', 'search_query']
         for field in required_fields:
             if field not in json_data:
@@ -179,7 +214,6 @@ def generate_search_query(prompt: str) -> dict:
             json_data['search_query'] = " ".join(search_parts).strip()
         
         return json_data
-
     except Exception as e:
         error_msg = f"❌ Ошибка извлечения данных: {str(e)}"
         message_queue.put(('log', error_msg))
@@ -195,7 +229,6 @@ def web_search(query: str) -> tuple:
     try:
         message_queue.put(('log', f"🔍 Провожу поиск по запросу: {query}"))
         start_time = time.time()
-
         params = {
             "api_key": os.getenv("SERPAPI_KEY"),
             "engine": "google",
@@ -205,35 +238,36 @@ def web_search(query: str) -> tuple:
             "num": 10,
             "safe": "off",
         }
-
         response = requests.get("https://serpapi.com/search", params=params, timeout=15)
         response.raise_for_status()
         data = response.json()
-
         combined_content = ""
         sources = []
         full_contents = []
-
+        
+        # Обработка featured snippet
         featured_snippet = data.get("featured_snippet", {})
         if featured_snippet:
             snippet = featured_snippet.get("snippet", "")
             if snippet:
-                combined_content += f"[Автоответ Google]\n{snippet}\n\n"
+                combined_content += f"[Автоответ Google]\n{snippet}\n"
                 sources.insert(0, {
                     "title": "Google — автоматический ответ",
                     "url": f"https://www.google.com/search?q={requests.utils.quote(query)}",
                     "content": snippet
                 })
-
+        
+        # Обработка organic results
         organic_results = data.get("organic_results", [])
-        for i, res in enumerate(organic_results[:5]):
+        for i, res in enumerate(organic_results[:5]):  # Ограничиваемся топ-5
             title = res.get("title", "Без заголовка")
             link = res.get("link", "#")
             snippet = res.get("snippet", "") or ""
-
+            
             if any(domain in link for domain in BLACKLISTED_DOMAINS):
                 continue
-
+            
+            # Загрузка полного контента
             content = None
             try:
                 headers = get_random_headers()
@@ -244,11 +278,13 @@ def web_search(query: str) -> tuple:
                 logging.error(f"Ошибка загрузки {link}: {str(e)}")
             
             if not content:
-                content = snippet
+                content = snippet  # Fallback на сниппет
             
+            # Форматирование контента
             cleaned_content = re.sub(r'\s+', ' ', content).strip()
-            combined_content += f"[[Источник {i+1}]] {title}\n{cleaned_content}\n\n"
+            combined_content += f"[[Источник {i+1}]] {title}\n{cleaned_content}\n"
             
+            # Сохранение источника
             source_data = {
                 "title": title,
                 "url": link,
@@ -256,46 +292,51 @@ def web_search(query: str) -> tuple:
             }
             sources.append(source_data)
             full_contents.append(cleaned_content[:MAX_CONTENT_LENGTH])
-
+        
         elapsed = time.time() - start_time
         message_queue.put(('log', f"✅ Поиск был произведен за {elapsed:.2f}с. Найдено {len(sources)} источников."))
         return combined_content[:20000], sources
-
     except Exception as e:
         error_msg = f"❌ SerpAPI ошибка: {str(e)}"
         message_queue.put(('log', error_msg))
         return f"Поиск недоступен: {str(e)}", []
 
-
 def clean_response(response: str, sources: list) -> str:
+    # Удаление служебных тегов
     response = re.sub(r'</?assistant>|<\|system\|>|</s>', '', response, flags=re.IGNORECASE)
+    # Удаление лишних разделителей
     response = re.sub(r'^-{3,}\s*', '', response)
+    # Удаление дублирования разделов
     response = re.sub(r'(\*\*Проблема:\*\*.+?)(\*\*Проблема:\*\*)', r'\1', response, flags=re.DOTALL)
     response = re.sub(r'(\*\*Решение:\*\*.+?)(\*\*Решение:\*\*)', r'\1', response, flags=re.DOTALL)
-    response = re.sub(r'\n\s*\n', '\n\n', response)
+    # Удаление лишних переносов
+    response = re.sub(r'\n\s*\n', '\n', response)
     response = re.sub(r'[ \t]{2,}', ' ', response)
+    # Удаление начальных фраз
     response = re.sub(r'^Вот исправленный ответ[^:]+:\s*', '', response)
+    # Форматирование примечаний
     response = re.sub(r'^---\s*Примечания:\s*', '**Примечания:**\n', response)
-    response = re.sub(r'^---\s*Источники:\s*', '**Источники информации:**\n', response)
+    # Форматирование источников
+    response = re.sub(r'^---\s*Источники:\s*', '**Источники:**\n', response)
+    # Удаление лишних маркеров
     response = re.sub(r'^---\s*', '', response, flags=re.MULTILINE)
+    # Очистка завершающих символов
     response = re.sub(r'\s*\.{3,}\s*$', '', response)
     return response.strip()
 
 def verify_with_sources(response: str, sources: list) -> str:
+    """Проверяет соответствие ответа источникам с помощью LLM"""
     try:
         message_queue.put(('log', "🔍 Проверяю соответствие ответа источникам..."))
-        
-        sources_text = "\n\n".join([
+        sources_text = "\n".join([
             f"Источник {i+1} ({source['title']}):\n{source['content'][:1500]}"
             for i, source in enumerate(sources)
         ])
         
         verification_prompt = f"""
         Проверь соответствие решения источникам:
-        
         ### Ответ бота:
         {response}
-        
         ### Источники:
         {sources_text}
         
@@ -319,50 +360,60 @@ def verify_with_sources(response: str, sources: list) -> str:
         
         verified_response = verification.choices[0].message.content
         return verified_response.strip()
-    
     except Exception as e:
         error_msg = f"❌ Ошибка верификации: {str(e)}"
         message_queue.put(('log', error_msg))
         return response
 
-
-def process_query(prompt: str):
+def process_query(prompt: str, conversation_id: str):
     try:
+        conversation = conversations.get(conversation_id)
+        is_new_conversation = False
+        
+        # Создаем новый диалог, если его нет
+        if not conversation:
+            conversation = Conversation()
+            conversations[conversation_id] = conversation
+            is_new_conversation = True
+            message_queue.put(('log', "🔄 Начат новый диалог"))
+        
         start_time = time.time()
-        message_queue.put(('log', f"👤 Запрос: {prompt}"))
+        message_queue.put(('log', f"👤 Получен запрос: {prompt}"))
         
-        # Проверяем тип запроса
-        if prompt.strip().lower() == "/repeat":
-            message_queue.put(('log', "🔄 Пользователь запросил повтор последнего ответа"))
-            if 'last_response' in session:
-                message_queue.put(('response', session['last_response']))
-                message_queue.put(('sources', session.get('last_sources', '')))
-                message_queue.put(('done', ''))
-                return
-            else:
-                message_queue.put(('response', "❌ Нет предыдущего ответа для повтора"))
-                message_queue.put(('done', ''))
-                return
+        # Проверяем, является ли запрос продолжение�� диалога
+        is_follow_up = False
+        if not is_new_conversation and conversation.last_problem:
+            message_queue.put(('log', "🔍 Анализирую, является ли запрос продолжением диалога..."))
+            
+            # Запрашиваем у ИИ анализ контекста
+            follow_up_check = mistral_client.chat.complete(
+                model=MISTRAL_MODEL,
+                messages=[
+                    {"role": "system", "content": "Определи, является ли следующий запрос продолжением предыдущего диалога о конкретной проблеме с принтером и требует ли он нового поиска информации. Ответь только 'да' или 'нет'."},
+                    {"role": "user", "content": f"Предыдущая проблема: {conversation.last_problem}\nТекущий запрос: {prompt}"}
+                ],
+                max_tokens=10,
+                temperature=0.1
+            )
+            
+            is_follow_up = 'да' in follow_up_check.choices[0].message.content.lower()
+            message_queue.put(('log', f"🤖 Анализ показал, что запрос {'является продолжением' if is_follow_up else 'требует нового поиска'}"))
         
-        # Инициализируем историю диалога
-        if 'history' not in session:
-            session['history'] = []
-            new_dialog = True
-        else:
-            new_dialog = False
-
-        # Определяем, нужен ли поиск
-        need_search = new_dialog or not any(msg['role'] == 'assistant' for msg in session['history'])
+        full_response = ""
+        final_response = ""
+        sources = []
         
-        # Для новых диалогов или первого сообщения - делаем поиск
-        if need_search:
+        if not is_follow_up or is_new_conversation:
+            # Полная обработка с поиском (как в оригинале)
             message_queue.put(('log', "⚙️ Извлекаю параметры из входящего запроса"))
             norm_data = generate_search_query(prompt)
             message_queue.put(('log', f"⏏️ Извлечено: {json.dumps(norm_data, ensure_ascii=False)}"))
             
             search_query = norm_data['search_query']
+            message_queue.put(('log', f"🌐 Формирую поисковый запрос: {search_query}"))
+            
             search_data, sources = web_search(search_query)
-            message_queue.put(('log', f"📚 Собрано: {len(search_data)} символов в {len(sources)} источнике(-ах)"))
+            message_queue.put(('log', f"📚 Собрано: {len(search_data)} символов в {len(sources)} источниках"))
             
             message_queue.put(('log', f"⚙️ Определяю проблему"))
             problem_response = mistral_client.chat.complete(
@@ -375,120 +426,180 @@ def process_query(prompt: str):
                 temperature=0.2
             )
             extracted_problem = problem_response.choices[0].message.content.strip()
-
             if not extracted_problem or len(extracted_problem) < 5:
                 extracted_problem = f"Неисправность {norm_data['brand']} {norm_data['model']}"
-
             message_queue.put(('log', f"🧩 Определённая проблема: {extracted_problem}"))
-
-            # Формируем системный промпт с результатами поиска
-            system_prompt = SYSTEM_PROMPT + f"""
-            Контекст:
-            Бренд: {norm_data['brand']}
-            Модель: {norm_data['model']}
-            Ошибка: {norm_data['error_code']}
-            Суть проблемы (на основе поиска): {extracted_problem}
-            Данные поиска:
-            {search_data}
-            """
-        else:
-            # Для продолжения диалога используем упрощенный системный промпт
-            system_prompt = SYSTEM_PROMPT_CONTINUE
-            sources = []
-            message_queue.put(('log', "💬 Продолжаю диалог на основе истории"))
-
-        # Собираем все сообщения для модели
-        messages = [{"role": "system", "content": system_prompt}]
-        
-        # Добавляем историю диалога (ограниченную по длине)
-        history = session['history'][-MAX_HISTORY_LENGTH*2:]  # Берем последние N пар сообщений
-        messages.extend(history)
-        
-        # Добавляем текущий запрос пользователя
-        messages.append({"role": "user", "content": prompt})
-        
-        message_queue.put(('log', "🧠 На основе полученных данных генерирую ответ..."))
-        
-        # Генерация ответа
-        full_response = ""
-        for chunk in mistral_client.chat.stream(
-            model=MISTRAL_MODEL,
-            messages=messages,
-            max_tokens=2048,
-            temperature=0.3
-        ):
-            if chunk.data.choices[0].delta.content is not None:
-                chunk_text = chunk.data.choices[0].delta.content
-                full_response += chunk_text
-
-        # Для новых запросов делаем верификацию
-        if need_search and sources:
+            
+            sources_text = "\n".join([f"[{i+1}] {s['title']} - {s['url']}" for i, s in enumerate(sources)])
+            
+            messages = [
+                {"role": "system", "content": SYSTEM_PROMPT + f"""
+                Контекст:
+                Бренд: {norm_data['brand']}
+                Модель: {norm_data['model']}
+                Ошибка: {norm_data['error_code']}
+                Суть проблемы (на основе поиска): {extracted_problem}
+                Данные поиска:
+                {search_data}
+                """},
+                {"role": "user", "content": f"Проблема: {prompt}"}
+            ]
+            
+            message_queue.put(('log', "🧠 На основе полученных данных генерирую ответ..."))
+            message_queue.put(('response_start', ""))
+            
+            for chunk in mistral_client.chat.stream(
+                model=MISTRAL_MODEL,
+                messages=messages,
+                max_tokens=2048,
+                temperature=0.3
+            ):
+                if chunk.data.choices[0].delta.content is not None:
+                    chunk_text = chunk.data.choices[0].delta.content
+                    full_response += chunk_text
+                    message_queue.put(('response_chunk', chunk_text))
+            
+            # Проверка соответствия источникам
             verified_response = verify_with_sources(full_response, sources)
+            # Очистка и форматирование ответа
             final_response = clean_response(verified_response, sources)
-        else:
-            final_response = clean_response(full_response, [])
-        
-        # Обновляем историю диалога
-        session['history'].append({"role": "user", "content": prompt})
-        session['history'].append({"role": "assistant", "content": final_response})
-        
-        # Сохраняем последний ответ для возможного повтора
-        session['last_response'] = final_response
-        if sources:
-            session['last_sources'] = json.dumps(sources)
-
-        # Отправляем ответ
-        message_queue.put(('response', final_response))
-        if sources:
+            
+            # Сохраняем контекст
+            conversation.add_exchange(
+                prompt, 
+                final_response,
+                sources=sources,
+                search_query=search_query,
+                problem=extracted_problem,
+                norm_data=norm_data,
+                full_response=full_response
+            )
+            
+            message_queue.put(('response_end', final_response))
             message_queue.put(('sources', json.dumps(sources)))
+        else:
+            # Обработка в контексте предыдущего диалога
+            message_queue.put(('log', "🔄 Обрабатываю запрос в контексте предыдущего диалога"))
+            
+            # Создаем контекст из предыдущего диалога
+            context = conversation.get_context()
+            
+            # Генерируем ответ на основе контекста
+            messages = [
+                {"role": "system", "content": SYSTEM_PROMPT + """
+                Вы отвечаете в контексте предыдущего диалога. 
+                Используйте предоставленную информацию вместо поиска в интернете.
+                Формат ответа должен быть таким же, как и при первом запросе.
+                """},
+                {"role": "user", "content": f"Контекст предыдущего диалога:\n{context}\n\nНовый запрос: {prompt}"}
+            ]
+            
+            message_queue.put(('log', "🧠 Генерирую ответ на основе контекста..."))
+            message_queue.put(('response_start', ""))
+            
+            for chunk in mistral_client.chat.stream(
+                model=MISTRAL_MODEL,
+                messages=messages,
+                max_tokens=2048,
+                temperature=0.3
+            ):
+                if chunk.data.choices[0].delta.content is not None:
+                    chunk_text = chunk.data.choices[0].delta.content
+                    full_response += chunk_text
+                    message_queue.put(('response_chunk', chunk_text))
+            
+            # Очистка и форматирование ответа
+            final_response = clean_response(full_response, conversation.last_sources)
+            
+            # Сохраняем в историю
+            conversation.add_exchange(prompt, final_response)
+            
+            # Отправляем ответ и источники
+            message_queue.put(('response_end', final_response))
+            message_queue.put(('sources', json.dumps(conversation.last_sources)))
         
+        message_queue.put(('log', f"💡 Ответ: {final_response[:200]}..."))
         total_time = time.time() - start_time
-        message_queue.put(('log', f"💡 Ответ сгенерирован"))
-        message_queue.put(('log', f"⏱ Время обработки: {total_time:.1f}с"))
+        message_queue.put(('log', f"⏱ Обработка завершена за {total_time:.1f}с"))
         message_queue.put(('done', ''))
-
     except Exception as e:
-        error_msg = f"❌ Ошибка обработки: {str(e)}"
+        error_msg = f"❌ Ошибка: {str(e)}"
         message_queue.put(('log', error_msg))
-        message_queue.put(('response', "\n⚠️ Произошла ошибка при обработке запроса"))
+        message_queue.put(('response', "\n⚠️ Ошибка обработки запроса"))
         message_queue.put(('done', ''))
 
-
 @app.route('/')
 def index():
-    # Инициализируем сессию при первом заходе
-    if 'history' not in session:
-        session['history'] = []
-    return render_template('index.html')
-
+    # Генерируем или получаем ID диалога
+    conversation_id = request.cookies.get('conversation_id')
+    if not conversation_id:
+        conversation_id = str(uuid4())
+    
+    response = make_response(render_template('index.html', conversation_id=conversation_id))
+    response.set_cookie('conversation_id', conversation_id)
+    return response
 
 @app.route('/ask', methods=['POST'])
 def ask():
     user_input = request.form['message']
-    thread = threading.Thread(target=process_query, args=(user_input,))
+    conversation_id = request.form.get('conversation_id', 'default')
+    
+    thread = threading.Thread(
+        target=process_query, 
+        args=(user_input, conversation_id)
+    )
     thread.daemon = True
     thread.start()
-    return jsonify({'status': 'processing'})
-
+    
+    return jsonify({
+        'status': 'processing',
+        'conversation_id': conversation_id
+    })
 
-@app.route('/repeat', methods=['POST'])
+@app.route('/repeat_last', methods=['POST'])
 def repeat_last():
-    """Повтор последнего ответа"""
-    thread = threading.Thread(target=process_query, args=("/repeat",))
-    thread.daemon = True
-    thread.start()
-    return jsonify({'status': 'repeating'})
-
-
-@app.route('/new', methods=['POST'])
-def new_dialog():
-    """Начало нового диалога"""
-    session.pop('history', None)
-    session.pop('last_response', None)
-    session.pop('last_sources', None)
-    session['history'] = []
-    return jsonify({'status': 'new_dialog_created'})
+    conversation_id = request.form.get('conversation_id', 'default')
+    conversation = conversations.get(conversation_id)
+    
+    if conversation and conversation.history:
+        last_exchange = conversation.history[-1]
+        message_queue.put(('log', "🔄 Повторяю последний ответ"))
+        message_queue.put(('response_start', ""))
+        
+        # Отправляем ответ по частям для анимации
+        chunk_size = 50
+        for i in range(0, len(last_exchange['bot']), chunk_size):
+            chunk = last_exchange['bot'][i:i+chunk_size]
+            message_queue.put(('response_chunk', chunk))
+            time.sleep(0.05)  # Небольшая задержка для эффекта печати
+        
+        message_queue.put(('response_end', last_exchange['bot']))
+        message_queue.put(('sources', json.dumps(conversation.last_sources)))
+        message_queue.put(('done', ''))
+        
+        return jsonify({'status': 'success'})
+    return jsonify({'status': 'error', 'message': 'No previous response to repeat'}), 404
 
+@app.route('/new_conversation', methods=['POST'])
+def new_conversation():
+    old_id = request.form.get('conversation_id', 'default')
+    
+    # Создаем новый ID
+    new_id = str(uuid4())
+    
+    # Перемещаем данные диалога (если нужно сохранить историю)
+    if old_id in conversations:
+        conversations[new_id] = conversations[old_id]
+        # Сбрасываем историю для нового диалога
+        conversations[new_id].history = []
+        conversations[new_id].last_sources = []
+        conversations[new_id].last_search_query = ""
+        conversations[new_id].last_problem = ""
+        conversations[new_id].last_norm_data = {}
+        del conversations[old_id]
+    
+    message_queue.put(('log', "🔄 Начат новый диалог"))
+    return jsonify({'status': 'success', 'new_conversation_id': new_id})
 
 @app.route('/stream')
 def stream():
@@ -502,6 +613,5 @@ def stream():
                 time.sleep(0.1)
     return Response(generate(), mimetype='text/event-stream')
 
-
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860, debug=False)