Upload 4 files

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.10-slim
+
+WORKDIR /code
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    git-lfs \
+    libgomp1 \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN git lfs install
+
+ENV HF_HUB_ENABLE_XET=0
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+RUN apt-get purge -y build-essential \
+    && apt-get autoremove -y --purge \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /tmp/models && chmod -R 777 /tmp/models
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,425 @@
+from flask import Flask, render_template, request, Response, jsonify
+from llama_cpp import Llama
+import logging
+import time
+import requests
+import re
+import threading
+import queue
+import json
+from huggingface_hub import hf_hub_download
+import os
+import html
+
+app = Flask(__name__)
+app.secret_key = 'super_secret_key'
+
+message_queue = queue.Queue()
+
+# Конфигурация модели
+MODEL_REPO = "QuantFactory/Meta-Llama-3-8B-Instruct-GGUF"
+MODEL_FILE = "Meta-Llama-3-8B-Instruct.Q5_K_M.gguf"
+
+# Загрузка модели при запуске
+MODEL_PATH = hf_hub_download(
+    repo_id=MODEL_REPO,
+    filename=MODEL_FILE,
+    cache_dir="/tmp/models",
+    local_files_only=False,
+    force_download=False,
+    resume_download=None,
+    etag_timeout=30,
+    token=None,
+)
+
+N_CTX = 4096
+
+SEARCH_API = "https://serpapi.com/search"
+API_KEY = "31c06fe621064f426c444cbdae5bd3821dd0572a6d23f445896ad5f3df6dc634"
+MAX_RESULTS = 7
+
+llm = Llama(
+    model_path=MODEL_PATH,
+    n_ctx=N_CTX,
+    n_threads=8,
+    n_gpu_layers=35,
+    temperature=0.2,
+    top_k=20,
+    top_p=0.8,
+    repeat_penalty=1.25
+)
+
+SYSTEM_PROMPT = """
+Ты PrintMaster, сервисный инженер по печатной технике. Строго соблюдай правила:
+1. Формат ответа ТОЛЬКО:
+   **Проблема:** [1 предложение]
+   **Решение:** [нумерованные шаги]
+2. После решения НИЧЕГО не добавляй
+3. Используй ТОЛЬКО корректные технические термины, если не знаешь как правильно перевести - пиши наименование на английском языке
+4. Решение должно содержать 3-7 четких шагов
+5. Каждый шаг должен быть полным предложением
+6. Не используй сокращения
+7. Запрещено добавлять примечания, предупреждения или рекомендации
+8. Отвечай ТОЛЬКО на русском языке
+"""
+
+OFFICIAL_DOMAINS = {
+    'sansamung': ['samsung.com']
+}
+
+BLACKLISTED_DOMAINS = [
+    'tikitokitok.com'
+]
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("/tmp/printer_assistant.log"),
+        logging.StreamHandler()
+    ]
+)
+
+def generate_search_query(prompt: str) -> dict:
+    """Используем ИИ для извлечения структурированной информации"""
+    BRAND_ALIASES = {
+        "hp": "HP", "hewlett-packard": "HP", "hewlett packard": "HP",
+        "хп": "HP", "эйчпи": "HP", "h-p": "HP",
+        "коника": "Konica Minolta", "конике": "Konica Minolta", 
+        "коника минолта": "Konica Minolta", "konica": "Konica Minolta",
+        "кэнон": "Canon", "кэноне": "Canon", "канон": "Canon",
+        "каноне": "Canon", "кенон": "Canon", "canon": "Canon",
+        "ксерокс": "Xerox", "ксероксе": "Xerox", "xerox": "Xerox",
+        "эпсон": "Epson", "epson": "Epson",
+        "братер": "Brother", "brother": "Brother",
+        "рико": "Ricoh", "ricoh": "Ricoh",
+        "киосера": "Kyocera", "kyocera": "Kyocera",
+        "лексмарк": "Lexmark", "lexmark": "Lexmark",
+        "самсунг": "Samsung", "samsung": "Samsung"
+    }
+    
+    extraction_prompt = f"""
+    <|system|>Извлеки информацию из запроса в формате JSON:
+    - brand: английское название бренда (Konica Minolta, Canon и т.д.)
+    - model: модель оборудования
+    - error_code: код ошибки (если есть)
+    - problem_description: краткое описание проблемы на русском
+    
+    Примеры:
+    Запрос: "коника с308 выдает ошибку c255c"
+    Ответ: {{"brand": "Konica Minolta", "model": "bizhub C308", "error_code": "C255C", "problem_description": "ошибка C255C"}}
+    
+    Запрос: "не печатает hp laserjet 1020"
+    Ответ: {{"brand": "HP", "model": "LaserJet 1020", "error_code": "", "problem_description": "принтер не печатает"}}
+    
+    Запрос: "Hewlett-Packard Color LJ MFP E 77825 Ошибка 63.00.41"
+    Ответ: {{"brand": "HP", "model": "Color LaserJet MFP E77825", "error_code": "63.00.41", "problem_description": "ошибка 63.00.41"}}
+    </s>
+    <|user|>{prompt}</s>
+    <|assistant|>
+    """
+    
+    response = llm(
+        extraction_prompt,
+        max_tokens=250,
+        stop=["</s>"],
+        temperature=0.1
+    )
+    
+    json_text = response['choices'][0]['text'].strip()
+    
+    try:
+        # Удаляем все символы до первой { и после последней }
+        json_start = json_text.find('{')
+        json_end = json_text.rfind('}') + 1
+        
+        if json_start == -1 or json_end == 0:
+            raise ValueError("JSON не найден в ответе")
+            
+        json_str = json_text[json_start:json_end]
+        norm_data = json.loads(json_str)
+        
+        # Нормализация бренда
+        brand_lower = norm_data['brand'].lower()
+        norm_data['brand'] = BRAND_ALIASES.get(brand_lower, norm_data['brand'])
+        
+        # Формируем поисковый запрос
+        if norm_data['error_code']:
+            search_query = f"{norm_data['brand']} {norm_data['model']} error code {norm_data['error_code']}"
+        else:
+            search_query = f"{norm_data['brand']} {norm_data['model']} {norm_data['problem_description']} troubleshooting"
+            
+        norm_data['search_query'] = re.sub(r'\s+', ' ', search_query).strip()
+        return norm_data
+        
+    except Exception as e:
+        message_queue.put(('log', f"❌ Ошибка извлечения данных: {str(e)}"))
+        message_queue.put(('log', f"🔍 Ответ модели: {json_text}"))
+        
+        # Fallback: извлекаем данные вручную
+        error_match = re.search(r'(\b[CcEe]\s?-?\s?\d{2,4}[A-Za-z]?\b|\d{2,3}\.\d{2}\.\d{2,3})', prompt)
+        model_match = re.search(
+            r'(?:\b(?:Color\s*)?(?:LaserJet|LJ|Phaser|image?CLASS|bizhub|WorkCentre|AltaLink|VersaLink|Multifunc|MFP)\s*[A-Za-z]?\s*\d{2,5}[A-Za-z]*(?:\s*\w+)?\b', 
+            prompt, 
+            re.IGNORECASE
+        )
+        brand = next((alias for name, alias in BRAND_ALIASES.items() 
+                     if name in prompt.lower()), '')
+        
+        return {
+            'brand': brand,
+            'model': model_match.group(0) if model_match else '',
+            'error_code': error_match.group(0).replace(' ', '') if error_match else '',
+            'problem_description': prompt,
+            'search_query': prompt
+        }
+
+def web_search(query: str) -> tuple:
+    """Поиск через SerpAPI (Google) с поддержкой featured_snippet"""
+    try:
+        message_queue.put(('log', f"🔍 Провожу поиск по запросу: {query}"))
+        start_time = time.time()
+        
+        params = {
+            "api_key": API_KEY,
+            "engine": "google",
+            "q": query,
+            "hl": "ru",
+            "gl": "ru",
+            "num": 15,
+            "safe": "off",
+        }
+
+        response = requests.get(SEARCH_API, params=params, timeout=20)
+        response.raise_for_status()
+        data = response.json()
+
+        combined_content = ""
+        sources = []
+        official_sources = []
+
+        # Обработка 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"
+                sources.insert(0, {
+                    "title": "Google Автоответ",
+                    "url": f"https://www.google.com/search?q={requests.utils.quote(query)}"
+                })
+
+        # Обработка органических результатов
+        organic_results = data.get("organic_results", [])
+        for res in organic_results:
+            title = res.get("title", "Без заголовка")
+            link = res.get("link", "#")
+            snippet = res.get("snippet", "") or ""
+            
+            # Проверка домена
+            domain = re.search(r'https?://([^/]+)', link)
+            if not domain:
+                continue
+            domain = domain.group(1).lower()
+            
+            # Фильтр по чёрному списку
+            if any(bl_domain in domain for bl_domain in BLACKLISTED_DOMAINS):
+                continue
+                
+            # Проверка официальных источников
+            is_official = False
+            for brand, domains in OFFICIAL_DOMAINS.items():
+                if any(official_domain in domain for official_domain in domains):
+                    is_official = True
+                    break
+                    
+            cleaned_snippet = re.sub(r'<[^>]+>|\n', ' ', snippet)
+            source_data = {"title": title, "url": link}
+            
+            if is_official:
+                official_sources.append(source_data)
+                combined_content = f"[[Официальный источник]] {title}\n{cleaned_snippet}\n\n" + combined_content
+            else:
+                sources.append(source_data)
+                combined_content += f"[[Источник]] {title}\n{cleaned_snippet}\n\n"
+
+        # Приоритет для официальных источников
+        sources = official_sources + sources[:MAX_RESULTS]
+        
+        elapsed = time.time() - start_time
+        message_queue.put(('log', f"✅ Поиск был произведен за {elapsed:.2f}с"))
+        return combined_content[:8000], 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) -> str:
+    # Удаляем служебные теги
+    response = re.sub(r'</?assistant>|<\|system\|>|</s>', '', response, flags=re.IGNORECASE)
+    
+    # Удаляем дублирование разделов
+    response = re.sub(r'(\*\*Проблема:\*\*.+?)(\*\*Проблема:\*\*)', r'\1', response, flags=re.DOTALL)
+    response = re.sub(r'(\*\*Решение:\*\*.+?)(\*\*Решение:\*\*)', r'\1', response, flags=re.DOTALL)
+    response = re.sub(r'(\*\*Источники:\*\*.+?)(\*\*Источники:\*\*)', r'\1', response, flags=re.DOTALL)
+    
+    # Убираем лишние переносы в нумерованных списках
+    response = re.sub(r'(\d+)\.\s*\n', r'\1. ', response)
+    response = re.sub(r'\n\s*\n', '\n\n', response)  # Убираем лишние пробелы между абзацами
+    response = re.sub(r'[ \t]+', ' ', response)      # Заменяем множественные пробелы/табы
+    
+    # Убираем [Решение]
+    response = re.sub(r'\s*\[Решение\]\s*', '', response)
+    
+    # Удаляем пустые разделы
+    response = re.sub(r'\*\*Источники:\*\*\s*$', '', response)
+    
+    # Удаляем HTML-теги и экранируем символы
+    response = html.escape(response)
+    
+    # Обрезаем до последней точки
+    last_dot = response.rfind('.')
+    if last_dot != -1:
+        response = response[:last_dot+1]
+    
+    return response.strip()
+
+def process_query(prompt: str):
+    try:
+        start_time = time.time()
+        message_queue.put(('log', f"👤 Запрос: {prompt}"))
+        message_queue.put(('log', f"⚙️ Извлекаю параметры из входящего запроса"))
+        
+        # Извлекаем данные
+        norm_data = generate_search_query(prompt)
+        message_queue.put(('log', f"✅ Извлечено: {json.dumps(norm_data, ensure_ascii=False)}"))
+        
+        # Выполняем поиск
+        search_data, sources = web_search(norm_data['search_query'])
+        message_queue.put(('log', f"📚 Результаты поиска: {len(search_data)} символов, источники: {len(sources)}"))
+
+        message_queue.put(('log', f"⚙️ Определяю проблему"))
+        
+        # Формируем промпт для анализа проблемы
+        problem_analysis_prompt = f"""
+        <|system|>
+        Сформулируй СУТЬ проблемы в одном предложении
+        Суммируй только факты из поисковых данных
+        Пиши только официальные технические термины
+        ТОЛЬКО СУТЬ без предположений и рекомендаций
+        Сделай это максимально конкретно
+        Это должно быть короткое предложение по типу "Ошибка C255C: поломка блока проявки"
+        </s>
+        <|user|>
+        Запрос: {prompt}
+        Данные поиска:
+        {search_data[:2000]} [обрезка для экономии токенов]
+        </s>
+        <|assistant|>
+        """
+
+        problem_response = llm(
+            problem_analysis_prompt,
+            max_tokens=150,
+            temperature=0.2,
+            stop=["</s>", "<|user|>"]
+        )
+        extracted_problem = problem_response['choices'][0]['text'].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}"))
+
+        # Формируем финальный промпт
+        response_prompt = f"""
+        <|system|>{SYSTEM_PROMPT}
+        Контекст:
+        Бренд: {norm_data['brand']}
+        Модель: {norm_data['model']}
+        Код ошибки: {norm_data['error_code']}
+        Суть проблемы: {extracted_problem}
+        Данные поиска:
+        {search_data}
+        </s>
+        <|user|>Проблема: {prompt}</s>
+        <|assistant|>
+        """
+        
+        message_queue.put(('log', "🧠 Генерирую ответ..."))
+        message_queue.put(('response_start', ""))
+        
+        # Генерируем ответ
+        response = llm.create_completion(
+            response_prompt,
+            max_tokens=1200,
+            temperature=0.3,
+            stop=["</s>", "<|user|>"],
+            stream=True
+        )
+        
+        full_response = ""
+        for output in response:
+            text_chunk = output['choices'][0]['text']
+            message_queue.put(('response_chunk', text_chunk))
+            full_response += text_chunk
+        
+        # Очищаем и структурируем ответ
+        final_response = clean_response(full_response)
+        
+        # Добавляем критически важные шаги, если они пропущены
+        critical_steps = []
+        if "перепрошивк" in search_data.lower() or "firmware" in search_data.lower():
+            critical_steps.append("Выполните перепрошивку устройства до последней версии")
+        if "замените" in search_data.lower() or "replace" in search_data.lower():
+            critical_steps.append("При необходимости замените неисправные компоненты на оригинальные")
+        
+        if critical_steps:
+            solution_section = re.search(r'\*\*Решение:\*\*(.+?)', 
+                                        final_response, 
+                                        flags=re.DOTALL)
+            if solution_section:
+                updated_solution = solution_section.group(1) + "\n" + "\n".join(critical_steps)
+                final_response = final_response.replace(solution_section.group(1), updated_solution)
+        
+        message_queue.put(('response_end', final_response))
+        message_queue.put(('sources', json.dumps(sources)))
+        
+        total_time = time.time() - start_time
+        message_queue.put(('log', f"💡 Ответ: {final_response}"))
+        message_queue.put(('log', f"⏱ Время: {total_time:.1f}с"))
+        message_queue.put(('done', ''))
+        
+    except Exception as e:
+        error_msg = f"❌ Ошибка: {str(e)}"
+        message_queue.put(('log', error_msg))
+        message_queue.put(('response', "\n⚠️ Ошибка обработки запроса"))
+        message_queue.put(('done', ''))
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/ask', methods=['POST'])
+def ask():
+    user_input = request.form['message']
+    thread = threading.Thread(target=process_query, args=(user_input,))
+    thread.daemon = True
+    thread.start()
+    return jsonify({'status': 'processing'})
+
+@app.route('/stream')
+def stream():
+    def generate():
+        while True:
+            if not message_queue.empty():
+                msg_type, content = message_queue.get()
+                data = json.dumps({"type": msg_type, "content": content})
+                yield f"data: {data}\n\n"
+            else:
+                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)

requirements.txt

@@ -0,0 +1,5 @@
+flask
+requests
+huggingface-hub==0.19.4
+llama-cpp-python==0.3.5 --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+gunicorn

template/index.html

@@ -0,0 +1,942 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>PrintMaster | Сервисный ассистент</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <style>
+        :root {
+            --primary: #4361ee;
+            --primary-light: #4895ef;
+            --secondary: #3f37c9;
+            --dark: #0e1424;
+            --light: #f8f9fa;
+            --gray: #e9ecef;
+            --success: #2ecc71;
+            --warning: #f39c12;
+            --danger: #e74c3c;
+            --transition: all 0.3s ease;
+        }
+        
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Segoe UI', system-ui, -apple-system, sans-serif;
+        }
+        
+        body {
+            background: linear-gradient(135deg, #f5f7fa 0%, #e4e7f1 100%);
+            color: var(--dark);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        
+        .app-container {
+            max-width: 1200px;
+            margin: 0 auto;
+            display: grid;
+            grid-template-columns: 1fr 300px;
+            gap: 20px;
+        }
+        
+        .card {
+            background: rgba(255, 255, 255, 0.92);
+            border-radius: 16px;
+            border: none;
+            box-shadow: 0 8px 32px rgba(31, 38, 135, 0.1);
+            backdrop-filter: blur(4px);
+            overflow: hidden;
+            transition: var(--transition);
+        }
+        
+        .card:hover {
+            box-shadow: 0 12px 40px rgba(31, 38, 135, 0.15);
+        }
+        
+        .card-header {
+            background: white;
+            border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+            padding: 20px;
+            font-weight: 600;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+        
+        .card-body {
+            padding: 0;
+        }
+        
+        .chat-container {
+            height: calc(100vh - 200px);
+            display: flex;
+            flex-direction: column;
+            padding: 20px;
+            overflow-y: auto;
+        }
+        
+        .message {
+            max-width: 80%;
+            padding: 16px 20px;
+            margin-bottom: 16px;
+            border-radius: 18px;
+            line-height: 1.5;
+            position: relative;
+            animation: fadeIn 0.3s ease;
+            box-shadow: 0 2px 6px rgba(0, 0, 0, 0.03);
+            will-change: transform, opacity;
+        }
+        
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        
+        .user-message {
+            background: var(--primary);
+            color: white;
+            align-self: flex-end;
+            border-bottom-right-radius: 4px;
+        }
+        
+        .bot-message {
+            background: white;
+            border: 1px solid var(--gray);
+            align-self: flex-start;
+            border-bottom-left-radius: 4px;
+        }
+        
+        .message-header {
+            font-size: 12px;
+            opacity: 0.8;
+            margin-bottom: 8px;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+        
+        .input-area {
+            padding: 20px;
+            border-top: 1px solid rgba(0, 0, 0, 0.05);
+            background: white;
+        }
+        
+        .input-group {
+            display: flex;
+            gap: 10px;
+        }
+        
+        #user-input {
+            flex: 1;
+            border: 1px solid var(--gray);
+            border-radius: 12px;
+            padding: 14px 20px;
+            font-size: 16px;
+            transition: var(--transition);
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.03);
+        }
+        
+        #user-input:focus {
+            border-color: var(--primary-light);
+            box-shadow: 0 0 0 3px rgba(67, 97, 238, 0.15);
+            outline: none;
+        }
+        
+        #send-btn {
+            background: var(--primary);
+            color: white;
+            border: none;
+            border-radius: 12px;
+            padding: 0 24px;
+            font-weight: 600;
+            transition: var(--transition);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            box-shadow: 0 4px 6px rgba(67, 97, 238, 0.2);
+        }
+        
+        #send-btn:hover {
+            background: var(--secondary);
+            transform: translateY(-1px);
+        }
+        
+        #send-btn:active {
+            transform: translateY(1px);
+        }
+        
+        .typing-indicator {
+            display: flex;
+            gap: 6px;
+            padding: 20px;
+        }
+        
+        .typing-dot {
+            width: 10px;
+            height: 10px;
+            background: var(--primary-light);
+            border-radius: 50%;
+            animation: bounce 1.4s infinite ease-in-out both;
+        }
+        
+        .typing-dot:nth-child(1) { animation-delay: -0.32s; }
+        .typing-dot:nth-child(2) { animation-delay: -0.16s; }
+        
+        @keyframes bounce {
+            0%, 80%, 100% { transform: scale(0); }
+            40% { transform: scale(1); }
+        }
+        
+        .log-entry {
+            padding: 14px 20px;
+            border-bottom: 1px solid rgba(0, 0, 0, 0.03);
+            font-size: 14px;
+            line-height: 1.5;
+            animation: fadeIn 0.3s ease;
+        }
+        
+        .log-entry:last-child {
+            border-bottom: none;
+        }
+        
+        .log-timestamp {
+            font-size: 11px;
+            opacity: 0.6;
+            margin-right: 8px;
+        }
+        
+        .log-info { color: var(--primary); }
+        .log-success { color: var(--success); }
+        .log-warning { color: var(--warning); }
+        .log-error { color: var(--danger); }
+        
+        .problem-text {
+            font-weight: 600;
+            color: var(--primary);
+            margin-bottom: 8px;
+        }
+        
+        .solution-step {
+            padding-left: 20px;
+            position: relative;
+            margin-bottom: 6px;
+        }
+        
+        .solution-step:before {
+            content: "•";
+            position: absolute;
+            left: 8px;
+            color: var(--primary);
+            font-weight: bold;
+        }
+        
+        .sources-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            background: rgba(67, 97, 238, 0.1);
+            color: var(--primary);
+            padding: 6px 12px;
+            border-radius: 20px;
+            font-size: 14px;
+            margin-top: 15px;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+        
+        .sources-badge:hover {
+            background: rgba(67, 97, 238, 0.15);
+        }
+        
+        .status-indicator {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            font-size: 14px;
+            padding: 4px 12px;
+            border-radius: 20px;
+            background: rgba(46, 204, 113, 0.1);
+            color: var(--success);
+        }
+        
+        .status-indicator.offline {
+            background: rgba(231, 76, 60, 0.1);
+            color: var(--danger);
+        }
+        
+        .status-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: var(--success);
+        }
+        
+        .status-indicator.offline .status-dot {
+            background: var(--danger);
+        }
+        
+        .logo {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            font-weight: 700;
+            font-size: 20px;
+            color: var(--dark);
+        }
+        
+        .logo-icon {
+            width: 36px;
+            height: 36px;
+            background: var(--primary);
+            border-radius: 10px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+        }
+        
+        .source-item {
+            padding: 12px 16px;
+            border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+            transition: var(--transition);
+        }
+        
+        .source-item:hover {
+            background: rgba(67, 97, 238, 0.03);
+        }
+        
+        .source-title {
+            font-weight: 500;
+            margin-bottom: 4px;
+            display: block;
+        }
+        
+        .source-url {
+            font-size: 13px;
+            color: #6c757d;
+            display: block;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+        
+        .empty-state {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            text-align: center;
+            padding: 40px 20px;
+            color: #6c757d;
+        }
+        
+        .empty-state i {
+            font-size: 48px;
+            margin-bottom: 20px;
+            color: #dee2e6;
+        }
+        
+        .empty-state h4 {
+            font-weight: 500;
+            margin-bottom: 10px;
+            color: #495057;
+        }
+        
+        .example-badge {
+            display: inline-block;
+            background: white;
+            border: 1px solid var(--gray);
+            border-radius: 8px;
+            padding: 8px 16px;
+            margin: 6px;
+            font-size: 14px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.03);
+        }
+        
+        .log-container {
+            height: calc(100vh - 200px);
+            overflow-y: auto;
+        }
+        
+        .highlight {
+            background-color: #fff9c4;
+            padding: 2px 4px;
+            border-radius: 4px;
+            font-weight: 600;
+        }
+        
+        @media (max-width: 768px) {
+            .app-container {
+                grid-template-columns: 1fr;
+            }
+            
+            .chat-container {
+                height: 60vh;
+            }
+            
+            .log-container {
+                height: 30vh;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="app-container">
+        <div class="card main-card">
+            <div class="card-header">
+                <div class="logo">
+                    <div class="logo-icon">
+                        <i class="fas fa-print"></i>
+                    </div>
+                    <span>PrintMaster</span>
+                </div>
+                <div class="ms-auto status-indicator" id="status-indicator">
+                    <div class="status-dot"></div>
+                    <span>Подключено</span>
+                </div>
+            </div>
+            <div class="card-body">
+                <div class="chat-container" id="chat-container">
+                    <div class="empty-state">
+                        <i class="fas fa-comments"></i>
+                        <h4>Добро пожаловать в PrintMaster</h4>
+                        <p>Опишите проблему с вашим принтером или МФУ, и я помогу найти решение</p>
+                        <div class="mt-3">
+                            <div class="example-badge">HP LaserJet 1020 не печатает</div>
+                            <div class="example-badge">Konica Minolta C258 ошибка C-2557</div>
+                            <div class="example-badge">Canon i-SENSYS MF644Cdw зажевывает бумагу</div>
+                        </div>
+                    </div>
+                </div>
+                <div class="input-area">
+                    <div class="input-group">
+                        <input type="text" id="user-input" class="form-control" placeholder="Опишите проблему с принтером..." autocomplete="off">
+                        <button id="send-btn" class="btn">
+                            <i class="fas fa-paper-plane"></i>
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="card logs-card">
+            <div class="card-header">
+                <i class="fas fa-terminal"></i>
+                <span>Журнал обработки</span>
+            </div>
+            <div class="card-body">
+                <div class="log-container" id="logs-container">
+                    <div class="log-entry log-info">
+                        
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+    const chatContainer = document.getElementById('chat-container');
+    const userInput = document.getElementById('user-input');
+    const sendBtn = document.getElementById('send-btn');
+    const logsContainer = document.getElementById('logs-container');
+    const statusIndicator = document.getElementById('status-indicator');
+    const statusDot = statusIndicator.querySelector('.status-dot');
+    const statusText = statusIndicator.querySelector('span');
+    const welcomeState = document.querySelector('.empty-state');
+    
+    // Создаем стили для подсветки один раз
+    const highlightStyle = document.createElement('style');
+    highlightStyle.textContent = `
+        .highlight {
+            background-color: #fff9c4;
+            padding: 2px 4px;
+            border-radius: 4px;
+            font-weight: 600;
+        }
+    `;
+    document.head.appendChild(highlightStyle);
+    
+    let currentSources = [];
+    let isProcessing = false;
+    let eventSource = null;
+    let botMessageId = null;
+    let processingLog = [];
+    let responseBuffer = '';
+    let lastUpdate = 0;
+    const UPDATE_THROTTLE = 100; // ms
+    let chunkBuffer = "";
+    let chunkTimeout = null;
+    
+    // Технические термины для подсветки
+    const technicalTerms = [
+        'фузер', 'термистор', 'микроконтроллер', 'перепрошивка',
+        'нагревательный вал', 'контакты', 'разъем', 'плата', 'картридж',
+        'вал', 'дозирующее лезвие', 'чистящее лезвие', 'мусорный бункер',
+        'лоток', 'печка', 'бумагопровод', 'сенсор', 'датчик', 'лазер'
+    ];
+    
+    // Создаем регулярные выражения заранее
+    const technicalTermRegexes = technicalTerms.map(term => {
+        return { 
+            term: term,
+            regex: new RegExp(`(${term})`, 'gi') 
+        };
+    });
+    
+    // Функция добавления временной метки
+    function getTimestamp() {
+        const now = new Date();
+        return now.toLocaleTimeString([], {hour: '2-digit', minute:'2-digit', second:'2-digit'});
+    }
+    
+    // Функция добавления сообщения в журнал
+    function addLog(message, type = 'info') {
+        const logEntry = document.createElement('div');
+        logEntry.className = `log-entry log-${type}`;
+        logEntry.innerHTML = `
+            <span class="log-timestamp">${getTimestamp()}</span>
+            ${message}
+        `;
+        logsContainer.appendChild(logEntry);
+        logsContainer.scrollTop = logsContainer.scrollHeight;
+        processingLog.push(`[${getTimestamp()}] ${message}`);
+    }
+    
+    // Добавление сообщения пользователя
+    function addUserMessage(message) {
+        // Удаляем пустое состояние, если оно есть
+        if (welcomeState && welcomeState.parentElement === chatContainer) {
+            chatContainer.innerHTML = '';
+        }
+        
+        const messageDiv = document.createElement('div');
+        messageDiv.className = 'message user-message';
+        messageDiv.innerHTML = `
+            <div class="message-header">
+                <i class="fas fa-user"></i>
+                <span>Вы</span>
+                <span class="ms-auto">${getTimestamp()}</span>
+            </div>
+            <div>${escapeHtml(message)}</div>
+        `;
+        chatContainer.appendChild(messageDiv);
+        chatContainer.scrollTop = chatContainer.scrollHeight;
+    }
+    
+    // Добавление сообщения бота
+    function addBotMessage(content = '', isTyping = false) {
+        // Удаляем пустое состояние, если оно есть
+        if (welcomeState && welcomeState.parentElement === chatContainer) {
+            chatContainer.innerHTML = '';
+        }
+        
+        const messageDiv = document.createElement('div');
+        messageDiv.className = 'message bot-message';
+        
+        if (isTyping) {
+            messageDiv.id = 'bot-typing';
+            messageDiv.innerHTML = `
+                <div class="message-header">
+                    <i class="fas fa-robot"></i>
+                    <span>PrintMaster</span>
+                    <span class="ms-auto">${getTimestamp()}</span>
+                </div>
+                <div class="typing-indicator">
+                    <div class="typing-dot"></div>
+                    <div class="typing-dot"></div>
+                    <div class="typing-dot"></div>
+                </div>
+            `;
+        } else {
+            messageDiv.innerHTML = `
+                <div class="message-header">
+                    <i class="fas fa-robot"></i>
+                    <span>PrintMaster</span>
+                    <span class="ms-auto">${getTimestamp()}</span>
+                </div>
+                <div class="message-content">${formatContent(content)}</div>
+            `;
+            botMessageId = messageDiv.id = 'bot-message-' + Date.now();
+        }
+        
+        chatContainer.appendChild(messageDiv);
+        chatContainer.scrollTop = chatContainer.scrollHeight;
+        return messageDiv;
+    }
+    
+    // Обновление сообщения бота с троттлингом
+    function updateBotMessage(content) {
+        const botMessage = document.getElementById('bot-typing') || document.querySelector('.bot-message:last-child');
+        if (botMessage) {
+            const contentDiv = botMessage.querySelector('.message-content') || 
+                              botMessage.querySelector('div:last-child:not(.typing-indicator, .message-header)');
+            
+            if (contentDiv) {
+                contentDiv.innerHTML = formatContent(content);
+            } else {
+                // Если это сообщение с индикатором набора, заменяем его на полноценное сообщение
+                botMessage.innerHTML = `
+                    <div class="message-header">
+                        <i class="fas fa-robot"></i>
+                        <span>PrintMaster</span>
+                        <span class="ms-auto">${getTimestamp()}</span>
+                    </div>
+                    <div class="message-content">${formatContent(content)}</div>
+                `;
+                botMessage.id = 'bot-message-' + Date.now();
+                botMessageId = botMessage.id;
+            }
+            
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+    }
+    
+    // Оптимизированное обновление с троттлингом
+    function throttledUpdate(content) {
+        const now = Date.now();
+        if (now - lastUpdate > UPDATE_THROTTLE) {
+            updateBotMessage(content);
+            lastUpdate = now;
+        }
+    }
+    
+    // Форматирование контента с подсветкой технических терминов и структурированием
+    function formatContent(content) {
+        // Заменяем разделы на стилизованные блоки
+        content = content.replace(/\*\*Проблема:\*\*/g, 
+            '<div class="problem-text">Проблема:</div>');
+        content = content.replace(/\*\*Решение:\*\*/g, 
+            '<div class="mt-2">Решение:</div>');
+        content = content.replace(/\*\*Источники:\*\*/g, 
+            '<div class="mt-2">Источники:</div>');
+        
+        // Форматируем нумерованные списки
+        content = content.replace(/(\d+)\.\s*(.+?)(?=\n\d+\.|\n\n|$)/g, 
+            '<div class="solution-step">$2</div>');
+        
+        // Подсветка технических терминов с использованием предварительно созданных regex
+        technicalTermRegexes.forEach(item => {
+            content = content.replace(item.regex, '<span class="highlight">$1</span>');
+        });
+        
+        return content;
+    }
+    
+    // Добавление ссылок на источники
+    function addSourceLinks() {
+        if (!botMessageId || currentSources.length === 0) return;
+        
+        const messageDiv = document.getElementById(botMessageId);
+        if (!messageDiv) return;
+        
+        // Удаляем существующие ссылки, если они есть
+        const existingSources = messageDiv.querySelector('.sources-container');
+        if (existingSources) existingSources.remove();
+        
+        if (currentSources.length > 0) {
+            const sourcesContainer = document.createElement('div');
+            sourcesContainer.className = 'sources-container mt-3';
+            sourcesContainer.innerHTML = '<div class="font-bold text-gray-700 mb-2 flex items-center"><i class="fas fa-link mr-2"></i> Источники информации</div>';
+            
+            const linksContainer = document.createElement('div');
+            linksContainer.className = 'flex flex-wrap gap-2';
+            
+            currentSources.slice(0, 5).forEach((source, index) => {
+                const link = document.createElement('span');
+                link.className = 'sources-badge';
+                link.innerHTML = `<i class="fas fa-external-link-alt mr-1"></i> Источник ${index + 1}`;
+                link.dataset.sourceIndex = index;
+                
+                link.addEventListener('click', function(e) {
+                    e.preventDefault();
+                    const sourceIndex = parseInt(this.dataset.sourceIndex);
+                    showSourceDetails(sourceIndex);
+                });
+                
+                linksContainer.appendChild(link);
+            });
+            
+            sourcesContainer.appendChild(linksContainer);
+            messageDiv.appendChild(sourcesContainer);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+    }
+    
+    // Показ деталей источника
+    function showSourceDetails(sourceIndex) {
+        const source = currentSources[sourceIndex];
+        if (!source) return;
+        
+        // Создаем модальное окно
+        let modal = document.getElementById('source-modal');
+        if (!modal) {
+            modal = document.createElement('div');
+            modal.id = 'source-modal';
+            modal.style.cssText = `
+                position: fixed;
+                top: 0;
+                left: 0;
+                width: 100%;
+                height: 100%;
+                background: rgba(0,0,0,0.5);
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                z-index: 1000;
+            `;
+            
+            modal.innerHTML = `
+                <div class="modal-content" style="background: white; border-radius: 12px; width: 90%; max-width: 600px; max-height: 80vh; overflow: auto;">
+                    <div class="modal-header" style="padding: 15px; border-bottom: 1px solid #eee; display: flex; justify-content: space-between; align-items: center;">
+                        <h5 style="margin: 0; font-weight: 600;">Источник информации</h5>
+                        <button id="close-modal" style="background: none; border: none; font-size: 1.5rem; cursor: pointer;">&times;</button>
+                    </div>
+                    <div class="modal-body" style="padding: 15px;">
+                        <h6 style="font-weight: 600; margin-bottom: 5px;">Название:</h6>
+                        <p id="source-title" style="margin-bottom: 15px;"></p>
+                        
+                        <h6 style="font-weight: 600; margin-bottom: 5px;">URL:</h6>
+                        <a id="source-url" href="#" target="_blank" style="color: #4361ee; text-decoration: underline; display: block; margin-bottom: 15px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;"></a>
+                        
+                        <h6 style="font-weight: 600; margin-bottom: 5px;">Фрагмент:</h6>
+                        <div id="source-snippet" style="background: #f8f9fa; padding: 10px; border-radius: 8px; border-left: 3px solid #4361ee;"></div>
+                    </div>
+                    <div class="modal-footer" style="padding: 15px; border-top: 1px solid #eee; text-align: right;">
+                        <button id="open-source" class="btn btn-primary" style="background: #4361ee; color: white; border: none; padding: 8px 15px; border-radius: 6px; cursor: pointer; margin-right: 10px;">Открыть источник</button>
+                        <button id="close-modal-footer" class="btn btn-secondary" style="background: #e9ecef; color: #495057; border: none; padding: 8px 15px; border-radius: 6px; cursor: pointer;">Закрыть</button>
+                    </div>
+                </div>
+            `;
+            
+            document.body.appendChild(modal);
+            
+            // Обработчики закрытия модального окна
+            const closeModal = () => modal.remove();
+            
+            document.getElementById('close-modal').addEventListener('click', closeModal);
+            document.getElementById('close-modal-footer').addEventListener('click', closeModal);
+            
+            modal.addEventListener('click', (e) => {
+                if (e.target === modal || e.target.closest('#close-modal, #close-modal-footer')) {
+                    closeModal();
+                }
+            });
+        }
+        
+        // Заполняем данные
+        document.getElementById('source-title').textContent = source.title;
+        const sourceUrl = document.getElementById('source-url');
+        sourceUrl.textContent = source.url;
+        sourceUrl.href = source.url;
+        document.getElementById('source-snippet').textContent = source.snippet;
+        
+        // Обработчик открытия источника
+        document.getElementById('open-source').onclick = () => {
+            window.open(source.url, '_blank');
+        };
+        
+        // Показываем модальное окно
+        document.body.appendChild(modal);
+    }
+    
+    // Функция для экранирования HTML
+    function escapeHtml(unsafe) {
+        return unsafe
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "<")
+            .replace(/>/g, ">")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#039;");
+    }
+    
+    // Подключение потока данных
+    function connectStream() {
+        if (eventSource) eventSource.close();
+        
+        // Обновляем статус
+        statusText.textContent = 'Обработка запроса...';
+        statusDot.style.background = 'var(--warning)';
+        statusIndicator.classList.add('warning');
+        statusIndicator.classList.remove('success');
+        
+        eventSource = new EventSource('/stream');
+        
+        eventSource.onmessage = function(event) {
+            try {
+                const data = JSON.parse(event.data);
+                const { type, content } = data;
+                
+                if (type === 'log' || type === 'processing_log') {
+                    addLog(content, 'info');
+                } 
+                else if (type === 'response_start') {
+                    // Начало ответа - показываем индикатор набора
+                    if (!document.getElementById('bot-typing')) {
+                        addBotMessage('', true);
+                    }
+                } 
+                else if (type === 'response_chunk') {
+                    // Порция ответа - добавляем к буферу чанков
+                    chunkBuffer += content;
+                    
+                    // Обновляем с троттлингом
+                    clearTimeout(chunkTimeout);
+                    chunkTimeout = setTimeout(() => {
+                        responseBuffer += chunkBuffer;
+                        throttledUpdate(responseBuffer);
+                        chunkBuffer = "";
+                    }, 100);
+                } 
+                else if (type === 'response_end') {
+                    // Конец ответа - форматируем итоговый ответ
+                    responseBuffer += chunkBuffer;
+                    chunkBuffer = "";
+                    updateBotMessage(responseBuffer);
+                    addSourceLinks();
+                } 
+                else if (type === 'sources') {
+                    // Получение источников информации
+                    try {
+                        currentSources = JSON.parse(content);
+                        addSourceLinks();
+                    } catch (e) {
+                        console.error('Error parsing sources:', e);
+                        addLog('Ошибка обработки источников', 'error');
+                    }
+                } 
+                else if (type === 'done') {
+                    // Завершение обработки
+                    isProcessing = false;
+                    statusText.textContent = 'Подключено';
+                    statusDot.style.background = 'var(--success)';
+                    statusIndicator.classList.add('success');
+                    statusIndicator.classList.remove('warning');
+                    
+                    // Удаляем индикатор набора, если он остался
+                    const typingIndicator = document.getElementById('bot-typing');
+                    if (typingIndicator) {
+                        typingIndicator.remove();
+                    }
+                    
+                    // Закрываем соединение
+                    if (eventSource) {
+                        eventSource.close();
+                        eventSource = null;
+                    }
+                }
+            } catch (e) {
+                console.error('Error processing event:', e);
+                addLog(`Ошибка обработки данных: ${e.message}`, 'error');
+            }
+        };
+        
+        eventSource.onerror = function() {
+            addLog("⚠️ Поток данных прерван", 'error');
+            statusText.textContent = 'Ошибка соединения';
+            statusDot.style.background = 'var(--danger)';
+            statusIndicator.classList.add('danger');
+            statusIndicator.classList.remove('success', 'warning');
+            
+            if (eventSource) {
+                eventSource.close();
+                eventSource = null;
+            }
+            
+            // Попытка восстановления через 2 секунды
+            setTimeout(() => {
+                if (!isProcessing) {
+                    statusText.textContent = 'Подключено';
+                    statusDot.style.background = 'var(--success)';
+                    statusIndicator.classList.add('success');
+                    statusIndicator.classList.remove('danger');
+                }
+            }, 2000);
+        };
+    }
+    
+    // Отправка сообщения
+    function sendMessage() {
+        const message = userInput.value.trim();
+        if (!message || isProcessing) return;
+        
+        // Добавляем сообщение пользователя
+        addUserMessage(message);
+        userInput.value = '';
+        
+        // Обновляем статус
+        isProcessing = true;
+        statusText.textContent = 'Обработка запроса...';
+        statusDot.style.background = 'var(--warning)';
+        statusIndicator.classList.add('warning');
+        statusIndicator.classList.remove('success');
+        
+        // Скрываем примеры запросов
+        const examples = document.querySelector('.example-badge');
+        if (examples) {
+            examples.parentElement.style.display = 'none';
+        }
+        
+        // Очищаем предыдущие данные
+        currentSources = [];
+        processingLog = [];
+        responseBuffer = '';
+        botMessageId = null;
+        chunkBuffer = "";
+        
+        // Подключаемся к потоку данных
+        connectStream();
+        
+        // Отправляем запрос на сервер
+        fetch('/ask', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: `message=${encodeURIComponent(message)}`
+        })
+        .then(res => res.json())
+        .then(data => {
+            if (data.status === 'processing') {
+                addLog("⚙️ Запрос отправлен на сервер...", 'info');
+            }
+        })
+        .catch(err => {
+            addLog(`❌ Ошибка запроса: ${err.message}`, 'error');
+            isProcessing = false;
+            statusText.textContent = 'Ошибка соединения';
+            statusDot.style.background = 'var(--danger)';
+            statusIndicator.classList.add('danger');
+            statusIndicator.classList.remove('warning');
+            
+            // Восстанавливаем статус через 2 секунды
+            setTimeout(() => {
+                statusText.textContent = 'Подключено';
+                statusDot.style.background = 'var(--success)';
+                statusIndicator.classList.add('success');
+                statusIndicator.classList.remove('danger');
+            }, 2000);
+        });
+    }
+    
+    // Обработчик�� событий
+    sendBtn.addEventListener('click', sendMessage);
+    userInput.addEventListener('keypress', (e) => {
+        if (e.key === 'Enter') sendMessage();
+    });
+    
+    // Закрытие соединений при уходе со страницы
+    window.addEventListener('beforeunload', () => {
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+    });
+    
+    // Инициализация
+    addLog("Система инициализирована. Ожидание запроса...", 'info');
+});
+    </script>
+</body>
+</html>