Update app.py

app.py

@@ -10,18 +10,15 @@ from gradio import mount_gradio_app
 from huggingface_hub import hf_hub_download
 from llama_cpp import Llama
 
-# Конфигурация модели
+# --- КОНФИГУРАЦИЯ ---
 REPO_ID = "Qwen/Qwen2.5-Coder-7B-Instruct-GGUF"
 FILENAME = "qwen2.5-coder-7b-instruct-q5_k_m.gguf"
-
 CONTEXT_SIZE = 8192
-MAX_OUTPUT_TOKENS = 4096
+DEFAULT_MAX_TOKENS = 4096
 
 print(f"Loading model {REPO_ID}...")
 try:
     model_path = hf_hub_download(repo_id=REPO_ID, filename=FILENAME)
-
-    print("Initializing Llama...")
     llm = Llama(
         model_path=model_path,
         n_ctx=CONTEXT_SIZE,
@@ -30,11 +27,11 @@ try:
         verbose=True,
     )
 except Exception as e:
-    print(f"Critical Error loading model: {e}")
+    print(f"Critical Error: {e}")
     raise e
 
+# --- API (FastAPI) ---
 app = FastAPI()
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -51,12 +48,7 @@ async def chat_completions(request: Request):
         messages = data.get("messages", [])
         stream = data.get("stream", False)
         temperature = data.get("temperature", 0.4)
-        max_tokens = data.get("max_tokens", MAX_OUTPUT_TOKENS)
-
-        if not messages:
-            return JSONResponse(
-                content={"error": "No messages provided"}, status_code=400
-            )
+        max_tokens = data.get("max_tokens", DEFAULT_MAX_TOKENS)
 
         output = llm.create_chat_completion(
             messages=messages,
@@ -68,61 +60,39 @@ async def chat_completions(request: Request):
         if stream:
 
             def iter_content():
-                try:
-                    for chunk in output:
-                        yield f"data: {json.dumps(chunk)}\n\n"
-                except Exception as e:
-                    print(f"Streaming error: {e}")
-                    err_chunk = {
-                        "choices": [
-                            {
-                                "delta": {"content": f"\n[ERROR]: {str(e)}"},
-                                "finish_reason": "error",
-                            }
-                        ]
-                    }
-                    yield f"data: {json.dumps(err_chunk)}\n\n"
-                finally:
-                    yield "data: [DONE]\n\n"
-
-            return StreamingResponse(
-                iter_content(),
-                media_type="text/event-stream",
-                headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
-            )
+                for chunk in output:
+                    yield f"data: {json.dumps(chunk)}\n\n"
+                yield "data: [DONE]\n\n"
 
-        return JSONResponse(content=output)
+            return StreamingResponse(iter_content(), media_type="text/event-stream")
 
+        return JSONResponse(content=output)
     except Exception as e:
-        print(f"API Error: {e}")
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
 
-def gradio_interface(message, history):
-    messages = [
-        {
-            "role": "system",
-            "content": "You are an expert coding assistant. Write clean, efficient code.",
-        }
-    ]
+# --- ЛОГИКА ГЕНЕРАЦИИ ДЛЯ GRADIO ---
+def generate_response(message, history, system_prompt, temperature, max_tokens):
+    # Формируем сообщения
+    messages = [{"role": "system", "content": system_prompt}]
 
-    history_subset = history[-10:] if len(history) > 10 else history
+    # Берем последние 10 сообщений для экономии памяти
+    for user_msg, assistant_msg in history[-10:]:
+        messages.append({"role": "user", "content": user_msg})
+        messages.append({"role": "assistant", "content": assistant_msg})
 
-    for u, a in history_subset:
-        messages.append({"role": "user", "content": u})
-        messages.append({"role": "assistant", "content": a})
     messages.append({"role": "user", "content": message})
 
     partial_text = ""
     try:
-        response_stream = llm.create_chat_completion(
+        stream = llm.create_chat_completion(
             messages=messages,
-            max_tokens=MAX_OUTPUT_TOKENS,
-            temperature=0.4,
+            max_tokens=int(max_tokens),
+            temperature=float(temperature),
             stream=True,
         )
 
-        for chunk in response_stream:
+        for chunk in stream:
             delta = chunk["choices"][0]["delta"]
             if "content" in delta:
                 partial_text += delta["content"]
@@ -130,20 +100,141 @@ def gradio_interface(message, history):
 
     except Exception as e:
         traceback.print_exc()
-        error_msg = f"\n\n🚫 **Error:** {str(e)}\nTry refreshing the page or shortening the context."
-        yield partial_text + error_msg
-
-
-demo = gr.ChatInterface(
-    fn=gradio_interface,
-    title="Qwen 2.5 Coder (7B-Instruct)",
-    description="Running on CPU. Generation might be slow. Please be patient.",
-    examples=[
-        "Write a Python script to scrape a website.",
-        "Explain how asyncio works in Python.",
-    ],
+        yield partial_text + f"\n\n❌ **Error:** {str(e)}"
+
+
+# --- ИНТЕРФЕЙС (Gradio Blocks) ---
+
+# CSS для увеличения высоты окна чата и улучшения шрифтов кода
+custom_css = """
+#chatbot {
+    height: 70vh !important;
+    overflow: auto;
+}
+"""
+
+# Используем тему Soft для более приятного визуала
+theme = gr.themes.Soft(
+    primary_hue="blue", secondary_hue="slate", neutral_hue="slate", text_size="lg"
 )
 
+with gr.Blocks(theme=theme, css=custom_css, title="Qwen Coder Pro") as demo:
+    gr.Markdown("# 💻 Qwen 2.5 Coder Assistant")
+
+    with gr.Row():
+        # Левая колонка - Настройки (20% ширины)
+        with gr.Column(scale=1, min_width=250):
+            gr.Markdown("### ⚙️ Settings")
+
+            system_prompt = gr.Textbox(
+                label="System Prompt",
+                value="You are an expert coding assistant. Write clean, efficient code and explain it clearly.",
+                lines=4,
+                interactive=True,
+            )
+
+            temperature = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.4,
+                step=0.1,
+                label="Creativity (Temperature)",
+                info="Lower = more precise code. Higher = more creative.",
+            )
+
+            max_tokens = gr.Slider(
+                minimum=512,
+                maximum=8192,
+                value=4096,
+                step=256,
+                label="Max Response Length",
+                info="Limit the length of the answer.",
+            )
+
+            gr.Markdown("---")
+            clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary")
+
+        # Правая колонка - Чат (80% ширины)
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                elem_id="chatbot",
+                show_copy_button=True,  # Кнопка копирования кода
+                avatar_images=(
+                    None,
+                    "https://api.iconify.design/noto:robot.svg",
+                ),  # Иконка бота
+                type="messages",  # Новый формат сообщений Gradio
+            )
+
+            with gr.Row():
+                msg = gr.Textbox(
+                    show_label=False,
+                    placeholder="Type your code question here...",
+                    scale=8,
+                    container=False,
+                    lines=2,
+                )
+                submit_btn = gr.Button("Run ➤", variant="primary", scale=1)
+
+    # --- СВЯЗКА СОБЫТИЙ ---
+
+    # Функция обертка для обработки истории в новом формате Gradio
+    def user_input(user_message, history):
+        return "", history + [{"role": "user", "content": user_message}]
+
+    def bot_response(history, sys_p, temp, m_tok):
+        # Преобразуем формат истории Gradio (список словарей) в формат для модели (список кортежей для старой логики или обработка словарей напрямую)
+        # Здесь мы адаптируем логику под список словарей
+
+        messages = [{"role": "system", "content": sys_p}]
+        # Добавляем историю (исключая последнее сообщение, которое мы добавим сейчас для генерации,
+        # но в новом формате Gradio история уже содержит последнее сообщение пользователя)
+
+        # Конвертация для LlamaCPP
+        llama_messages = [{"role": "system", "content": sys_p}]
+
+        # Берем последние 20 сообщений
+        relevant_history = history[-20:]
+
+        for msg in relevant_history:
+            llama_messages.append({"role": msg["role"], "content": msg["content"]})
+
+        partial_text = ""
+        history.append({"role": "assistant", "content": ""})
+
+        try:
+            stream = llm.create_chat_completion(
+                messages=llama_messages,
+                max_tokens=int(m_tok),
+                temperature=float(temp),
+                stream=True,
+            )
+
+            for chunk in stream:
+                delta = chunk["choices"][0]["delta"]
+                if "content" in delta:
+                    partial_text += delta["content"]
+                    # Обновляем последнее сообщение ассистента в истории
+                    history[-1]["content"] = partial_text
+                    yield history
+
+        except Exception as e:
+            history[-1]["content"] = f"Error: {str(e)}"
+            yield history
+
+    # Отправка по Enter или кнопке
+    msg.submit(user_input, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot_response, [chatbot, system_prompt, temperature, max_tokens], chatbot
+    )
+
+    submit_btn.click(user_input, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot_response, [chatbot, system_prompt, temperature, max_tokens], chatbot
+    )
+
+    # Очистка
+    clear_btn.click(lambda: [], None, chatbot, queue=False)
+
 app = mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":