Deploy 2MOOD AI Workspace (Feedback + Messenger + KB)

app.py

@@ -0,0 +1,6 @@
+from app.main import build_interface
+
+app = build_interface()
+
+if __name__ == "__main__":
+    app.launch()

app/config.py

@@ -0,0 +1,18 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))  # .../app -> project root
+DATA_DIR = os.path.join(PROJECT_ROOT, "data")
+KB_DIR = os.path.join(DATA_DIR, "knowledge_base")
+PROTOCOLS_DIR = os.path.join(DATA_DIR, "protocols_archive")
+
+KB_FILES_DIR = os.path.join(KB_DIR, "files")
+KB_INDEX_PATH = os.path.join(KB_DIR, "kb_index.json")
+FEEDBACK_DB_PATH = os.path.join(DATA_DIR, "feedback.db")
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "").strip()
+
+TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "").strip()
+TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "").strip()

app/integrations/telegram_bot.py

@@ -0,0 +1,36 @@
+import os
+import requests
+
+
+def _get_env():
+    token = os.getenv("TELEGRAM_BOT_TOKEN", "").strip()
+    chat_id = os.getenv("TELEGRAM_CHAT_ID", "").strip()
+    enabled = bool(token and chat_id)
+    return enabled, token, chat_id
+
+
+def send_telegram_message(text: str) -> tuple[bool, str]:
+    """
+    Returns (ok, message)
+    """
+    enabled, token, chat_id = _get_env()
+    if not enabled:
+        return False, "Telegram отключён: нет TELEGRAM_BOT_TOKEN / TELEGRAM_CHAT_ID в .env"
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    payload = {
+        "chat_id": chat_id,
+        "text": text,
+        "disable_web_page_preview": True
+    }
+
+    try:
+        r = requests.post(url, json=payload, timeout=15)
+        if r.status_code != 200:
+            return False, f"Telegram error: HTTP {r.status_code} — {r.text}"
+        data = r.json()
+        if not data.get("ok"):
+            return False, f"Telegram error: {data}"
+        return True, "Отправлено в Telegram"
+    except Exception as e:
+        return False, f"Telegram exception: {e}"

app/knowledge/loader.py

@@ -0,0 +1,18 @@
+import os
+from pypdf import PdfReader
+
+def extract_text_from_pdf(pdf_path: str) -> str:
+    reader = PdfReader(pdf_path)
+    chunks = []
+    for page in reader.pages:
+        chunks.append(page.extract_text() or "")
+    return "\n".join(chunks).strip()
+
+def save_uploaded_pdf(src_path: str, dest_dir: str) -> str:
+    os.makedirs(dest_dir, exist_ok=True)
+    base = os.path.basename(src_path)
+    dest_path = os.path.join(dest_dir, base)
+    # перезапись ок для пилота
+    with open(src_path, "rb") as fsrc, open(dest_path, "wb") as fdst:
+        fdst.write(fsrc.read())
+    return dest_path

app/knowledge/vector_store.py

@@ -0,0 +1,119 @@
+import json
+import math
+import os
+import re
+from dataclasses import dataclass
+from typing import List, Dict, Any
+
+TOKEN_RE = re.compile(r"[A-Za-zА-Яа-я0-9_]+")
+
+def tokenize(text: str) -> List[str]:
+    return [t.lower() for t in TOKEN_RE.findall(text)]
+
+@dataclass
+class Doc:
+    doc_id: str
+    title: str
+    text: str
+    source_path: str
+
+class BM25Index:
+    """
+    Лёгкий BM25 без зависимостей.
+    Хранит документы + статистику в JSON.
+    """
+    def __init__(self, k1: float = 1.5, b: float = 0.75):
+        self.k1 = k1
+        self.b = b
+        self.docs: List[Doc] = []
+        self.df: Dict[str, int] = {}         # document frequency per term
+        self.tf: List[Dict[str, int]] = []   # term frequency per doc
+        self.doc_len: List[int] = []
+        self.avgdl: float = 0.0
+
+    def add(self, doc: Doc):
+        tokens = tokenize(doc.text)
+        tf_map: Dict[str, int] = {}
+        for t in tokens:
+            tf_map[t] = tf_map.get(t, 0) + 1
+        # update df
+        for t in set(tf_map.keys()):
+            self.df[t] = self.df.get(t, 0) + 1
+
+        self.docs.append(doc)
+        self.tf.append(tf_map)
+        self.doc_len.append(len(tokens))
+        self.avgdl = sum(self.doc_len) / max(1, len(self.doc_len))
+
+    def idf(self, term: str) -> float:
+        N = len(self.docs)
+        n = self.df.get(term, 0)
+        # classic BM25 idf
+        return math.log(1 + (N - n + 0.5) / (n + 0.5)) if N > 0 else 0.0
+
+    def score(self, query: str, i: int) -> float:
+        q_terms = tokenize(query)
+        score = 0.0
+        dl = self.doc_len[i]
+        denom_norm = (1 - self.b) + self.b * (dl / (self.avgdl or 1.0))
+        tf_map = self.tf[i]
+        for term in q_terms:
+            f = tf_map.get(term, 0)
+            if f <= 0:
+                continue
+            idf = self.idf(term)
+            score += idf * (f * (self.k1 + 1)) / (f + self.k1 * denom_norm)
+        return score
+
+    def search(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:
+        scored = []
+        for i, d in enumerate(self.docs):
+            s = self.score(query, i)
+            if s > 0:
+                scored.append((s, d))
+        scored.sort(key=lambda x: x[0], reverse=True)
+        results = []
+        for s, d in scored[:top_k]:
+            # короткий сниппет для UI
+            snippet = (d.text[:600] + "…") if len(d.text) > 600 else d.text
+            results.append({
+                "score": round(s, 4),
+                "doc_id": d.doc_id,
+                "title": d.title,
+                "source_path": d.source_path,
+                "snippet": snippet
+            })
+        return results
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "k1": self.k1,
+            "b": self.b,
+            "docs": [{"doc_id": d.doc_id, "title": d.title, "text": d.text, "source_path": d.source_path} for d in self.docs],
+            "df": self.df,
+            "tf": self.tf,
+            "doc_len": self.doc_len,
+            "avgdl": self.avgdl
+        }
+
+    @staticmethod
+    def from_json(obj: Dict[str, Any]) -> "BM25Index":
+        idx = BM25Index(k1=obj.get("k1", 1.5), b=obj.get("b", 0.75))
+        idx.docs = [Doc(**d) for d in obj.get("docs", [])]
+        idx.df = obj.get("df", {})
+        idx.tf = obj.get("tf", [])
+        idx.doc_len = obj.get("doc_len", [])
+        idx.avgdl = obj.get("avgdl", 0.0)
+        return idx
+
+def save_index(path: str, index: BM25Index):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(index.to_json(), f, ensure_ascii=False)
+
+def load_index(path: str) -> BM25Index:
+    if not os.path.exists(path):
+        return BM25Index()
+    with open(path, "r", encoding="utf-8") as f:
+        obj = json.load(f)
+    return BM25Index.from_json(obj)

app/main.py

@@ -0,0 +1,247 @@
+import os
+import sys
+import csv
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Tuple, List, Dict
+
+import gradio as gr
+import requests
+
+# Опционально: подтягиваем .env при локальном запуске
+try:
+    from dotenv import load_dotenv
+except Exception:
+    load_dotenv = None
+
+
+# --- Fix imports when запуск: `python app\main.py` из корня проекта ---
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+if load_dotenv:
+    load_dotenv(PROJECT_ROOT / ".env")
+
+
+# --- Paths ---
+DATA_DIR = PROJECT_ROOT / "data"
+FEEDBACK_DIR = DATA_DIR / "feedback"
+FEEDBACK_CSV = FEEDBACK_DIR / "feedback.csv"
+
+
+# --- Telegram integration ---
+def send_telegram_message(text: str) -> Tuple[bool, str]:
+    """
+    Отправляет сообщение в Telegram (если TELEGRAM_BOT_TOKEN и TELEGRAM_CHAT_ID заданы).
+    Возвращает (ok, details).
+    """
+    token = os.getenv("TELEGRAM_BOT_TOKEN", "").strip()
+    chat_id = os.getenv("TELEGRAM_CHAT_ID", "").strip()
+
+    if not token or not chat_id:
+        return False, "Telegram: пропущено (нет TELEGRAM_BOT_TOKEN или TELEGRAM_CHAT_ID)"
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    try:
+        r = requests.post(url, data={"chat_id": chat_id, "text": text}, timeout=10)
+        if r.status_code == 200:
+            return True, "Telegram: отправлено ✅"
+        return False, f"Telegram: ошибка {r.status_code}: {r.text[:200]}"
+    except Exception as e:
+        return False, f"Telegram: исключение: {e}"
+
+
+# --- Feedback storage ---
+def ensure_feedback_csv_exists() -> None:
+    FEEDBACK_DIR.mkdir(parents=True, exist_ok=True)
+    if not FEEDBACK_CSV.exists():
+        with FEEDBACK_CSV.open("w", newline="", encoding="utf-8") as f:
+            w = csv.writer(f)
+            w.writerow(["timestamp", "category", "rating", "contact", "feedback_text"])
+
+
+def append_feedback_row(category: str, rating: int, contact: str, feedback_text: str) -> None:
+    ensure_feedback_csv_exists()
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with FEEDBACK_CSV.open("a", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow([ts, category, rating, contact.strip(), feedback_text.strip()])
+
+
+# --- UI logic ---
+def save_feedback(category: str, rating: int, contact: str, feedback_text: str):
+    if not feedback_text or not feedback_text.strip():
+        return "⚠️ Введите текст обратной связи.", gr.update(value=feedback_text), None
+
+    if rating is None:
+        return "⚠️ Выберите оценку (1–5).", gr.update(value=feedback_text), None
+
+    try:
+        append_feedback_row(category, int(rating), contact or "", feedback_text)
+    except Exception as e:
+        return f"❌ Не удалось сохранить в CSV: {e}", gr.update(value=feedback_text), None
+
+    # Telegram уведомление (не блокирует сохранение)
+    tg_text = (
+        "📝 2MOOD Feedback\n"
+        f"Категория: {category}\n"
+        f"Оценка: {rating}\n"
+        f"Контакт: {contact or '-'}\n"
+        f"Текст: {feedback_text.strip()}"
+    )
+    tg_ok, tg_details = send_telegram_message(tg_text)
+
+    status = "✅ Отзыв сохранён в CSV.\n\n"
+    status += f"Файл: `{FEEDBACK_CSV.as_posix()}`\n\n"
+    status += ("✅ " if tg_ok else "⚠️ ") + tg_details
+
+    # очистим поле текста + выдадим файл (чтобы сразу можно было скачать при желании)
+    return status, gr.update(value=""), str(FEEDBACK_CSV)
+
+
+def get_feedback_csv() -> Tuple[Optional[str], str]:
+    if FEEDBACK_CSV.exists() and FEEDBACK_CSV.stat().st_size > 0:
+        return str(FEEDBACK_CSV), "✅ Готово: файл доступен для скачивания."
+    return None, "⚠️ Файл ещё не создан или пуст."
+
+
+# --- Messenger logic (Gradio Chatbot: messages format) ---
+def messenger_reply(user_message: str, history: Optional[List[Dict[str, str]]]):
+    """
+    Gradio Chatbot с type="messages" ожидает:
+    [{"role":"user","content":"..."}, {"role":"assistant","content":"..."} ...]
+    """
+    history = history or []
+
+    msg = (user_message or "").strip()
+    if not msg:
+        return "", history
+
+    history.append({"role": "user", "content": msg})
+    history.append({"role": "assistant", "content": f"Echo: {msg}"})
+
+    return "", history
+
+
+def build_interface():
+    ensure_feedback_csv_exists()
+
+    with gr.Blocks(title="2MOOD AI Workspace (Pilot)") as demo:
+        gr.Markdown("# 2MOOD AI Workspace")
+        gr.Markdown("База знаний + Messenger + Обратная связь")
+
+        with gr.Tab("📚 База знаний"):
+            gr.Markdown("Загрузка PDF и индексирование (пока заглушка)")
+            gr.File(label="Загрузить PDF")
+            gr.Button("Добавить в базу")
+
+        with gr.Tab("💬 2MOOD Messenger"):
+            # ВАЖНО: фиксируем формат, чтобы не ловить ошибку role/content
+            chat = gr.Chatbot(height=420, type="messages")
+            msg = gr.Textbox(label="Сообщение", placeholder="Напишите сообщение…")
+            send = gr.Button("Отправить", variant="primary")
+
+            send.click(messenger_reply, inputs=[msg, chat], outputs=[msg, chat])
+
+        with gr.Tab("📝 Обратная связь"):
+            category = gr.Dropdown(
+                label="Категория",
+                choices=["Другое", "Messenger", "База знаний", "UI/UX", "Ошибка/Баг", "Идея/Feature"],
+                value="Другое",
+            )
+
+            rating = gr.Radio(
+                label="Оценка",
+                choices=[1, 2, 3, 4, 5],
+                value=5,
+            )
+
+            contact = gr.Textbox(label="Контакт (опционально): Telegram/почта")
+            feedback_text = gr.Textbox(
+                label="Текст обратной связи",
+                lines=6,
+                placeholder="Например: не хватает кнопки…, ошибка…, хочу экспорт в Word…",
+            )
+
+            submit = gr.Button("Отправить", variant="primary")
+            status = gr.Markdown()
+
+            # Кнопка скачивания
+            download_btn = gr.Button("📥 Скачать все отзывы")
+            download_file = gr.File(label="Файл с отзывами", interactive=False)
+            download_status = gr.Markdown()
+
+            # Покажем текущий путь
+            gr.Markdown(f"Файл логов: `{FEEDBACK_CSV.as_posix()}`")
+
+            submit.click(
+                save_feedback,
+                inputs=[category, rating, contact, feedback_text],
+                outputs=[status, feedback_text, download_file],
+            )
+
+            download_btn.click(
+                get_feedback_csv,
+                inputs=None,
+                outputs=[download_file, download_status],
+            )
+
+    return demo
+
+
+def launch_with_port_fallback(demo: gr.Blocks):
+    """
+    Устойчивый запуск:
+    - сначала локально (127.0.0.1, share=False)
+    - если Gradio считает, что localhost недоступен (proxy/настройки) -> fallback share=True
+    """
+    # Частая причина "localhost is not accessible" — прокси/NO_PROXY
+    os.environ.setdefault("NO_PROXY", "localhost,127.0.0.1")
+    os.environ.setdefault("no_proxy", "localhost,127.0.0.1")
+
+    env_port = os.getenv("GRADIO_SERVER_PORT") or os.getenv("PORT") or ""
+    ports: List[int] = []
+    if str(env_port).isdigit():
+        ports.append(int(env_port))
+
+    ports.extend([7860] + list(range(7861, 7871)))
+
+    last_error: Optional[Exception] = None
+
+    for port in ports:
+        # 1) Локальная попытка
+        try:
+            demo.launch(
+                server_name="127.0.0.1",
+                server_port=port,
+                share=False,
+                inbrowser=True,
+            )
+            return
+        except Exception as e:
+            last_error = e
+            msg = str(e)
+
+            # 2) Fallback: если localhost недоступен по мнению Gradio
+            if "localhost is not accessible" in msg or "shareable link must be created" in msg:
+                try:
+                    demo.launch(
+                        server_name="0.0.0.0",
+                        server_port=port,
+                        share=True,
+                        inbrowser=False,
+                    )
+                    return
+                except Exception as e2:
+                    last_error = e2
+                    continue
+
+            continue
+
+    raise RuntimeError(f"Не удалось запустить Gradio ни на одном порту. Последняя ошибка: {last_error}")
+
+
+if __name__ == "__main__":
+    app = build_interface()
+    launch_with_port_fallback(app)

app/messendger/chat_engine.py

@@ -0,0 +1,29 @@
+from openai import OpenAI
+from app.config import OPENAI_API_KEY
+
+class ChatEngine:
+    def __init__(self):
+        self.client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
+
+    def answer(self, user_text: str, context: str = "") -> str:
+        # fallback, если ключа нет
+        if not self.client:
+            return "⚠️ OPENAI_API_KEY не задан. (Пилотный режим) Ваш вопрос: " + user_text
+
+        system = (
+            "Ты ассистент 2MOOD. Отвечай кратко и по делу. "
+            "Если дан контекст из базы знаний — опирайся на него и добавляй ссылки на источники (имя файла). "
+            "Если контекста нет — скажи, что в базе знаний не найдено подтверждение, и предложи уточнить."
+        )
+
+        user = f"Вопрос: {user_text}\n\nКонтекст из базы знаний:\n{context or '(нет)'}"
+
+        resp = self.client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.2,
+        )
+        return resp.choices[0].message.content.strip()

app/messendger/feedback_handler.py

@@ -0,0 +1,44 @@
+import os
+import sqlite3
+from datetime import datetime
+from app.config import FEEDBACK_DB_PATH
+from app.integrations.telegram_bot import send_telegram_message
+
+def _init_db():
+    os.makedirs(os.path.dirname(FEEDBACK_DB_PATH), exist_ok=True)
+    with sqlite3.connect(FEEDBACK_DB_PATH) as conn:
+        conn.execute("""
+        CREATE TABLE IF NOT EXISTS feedback (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            created_at TEXT,
+            author TEXT,
+            channel TEXT,
+            topic TEXT,
+            rating INTEGER,
+            message TEXT
+        )
+        """)
+        conn.commit()
+
+def save_feedback(author: str, channel: str, topic: str, rating: int, message: str) -> str:
+    _init_db()
+    ts = datetime.utcnow().isoformat(timespec="seconds") + "Z"
+    with sqlite3.connect(FEEDBACK_DB_PATH) as conn:
+        conn.execute(
+            "INSERT INTO feedback(created_at, author, channel, topic, rating, message) VALUES(?,?,?,?,?,?)",
+            (ts, author.strip(), channel.strip(), topic.strip(), int(rating), message.strip())
+        )
+        conn.commit()
+    return f"✅ Сохранено (UTC {ts})"
+
+def send_feedback_to_telegram(author: str, channel: str, topic: str, rating: int, message: str) -> str:
+    text = (
+        "🧾 2MOOD Feedback\n"
+        f"Автор: {author}\n"
+        f"Канал: {channel}\n"
+        f"Тема: {topic}\n"
+        f"Оценка: {rating}/5\n\n"
+        f"{message}"
+    )
+    ok, info = send_telegram_message(text)
+    return "✅ " + info if ok else "⚠️ " + info

app/services/knowledge_service.py

@@ -0,0 +1,46 @@
+import os
+import uuid
+from app.config import KB_FILES_DIR, KB_INDEX_PATH
+from app.knowledge.loader import extract_text_from_pdf, save_uploaded_pdf
+from app.knowledge.vector_store import BM25Index, Doc, save_index, load_index
+
+class KnowledgeService:
+    def __init__(self):
+        os.makedirs(KB_FILES_DIR, exist_ok=True)
+        self.index: BM25Index = load_index(KB_INDEX_PATH)
+
+    def add_pdf(self, uploaded_path: str) -> str:
+        dest_path = save_uploaded_pdf(uploaded_path, KB_FILES_DIR)
+        text = extract_text_from_pdf(dest_path)
+        if not text:
+            return f"⚠️ Не удалось извлечь текст из PDF: {os.path.basename(dest_path)}"
+
+        doc = Doc(
+            doc_id=str(uuid.uuid4())[:8],
+            title=os.path.basename(dest_path),
+            text=text,
+            source_path=dest_path
+        )
+        self.index.add(doc)
+        save_index(KB_INDEX_PATH, self.index)
+        return f"✅ Добавлено в базу: {doc.title} (id={doc.doc_id})"
+
+    def list_docs(self) -> str:
+        if not self.index.docs:
+            return "Пока нет документов. Загрузите PDF."
+        lines = [f"- {d.title} (id={d.doc_id})" for d in self.index.docs]
+        return "\n".join(lines)
+
+    def search(self, query: str, top_k: int = 5):
+        return self.index.search(query, top_k=top_k)
+
+    def build_context(self, query: str, top_k: int = 4) -> str:
+        hits = self.search(query, top_k=top_k)
+        if not hits:
+            return ""
+        blocks = []
+        for h in hits:
+            blocks.append(
+                f"[Источник: {h['title']} | score={h['score']}]\n{h['snippet']}"
+            )
+        return "\n\n---\n\n".join(blocks)

app/ui/gradio_app.py

@@ -0,0 +1,104 @@
+import gradio as gr
+from app.services.knowledge_service import KnowledgeService
+from app.messenger.chat_engine import ChatEngine
+from app.messenger.feedback_handler import save_feedback, send_feedback_to_telegram
+
+kb = KnowledgeService()
+chat = ChatEngine()
+
+def kb_add(pdf_file):
+    if pdf_file is None:
+        return "Загрузите PDF."
+    return kb.add_pdf(pdf_file)
+
+def kb_list():
+    return kb.list_docs()
+
+def kb_search(query, top_k):
+    hits = kb.search(query, top_k=int(top_k))
+    if not hits:
+        return "Ничего не найдено."
+    out = []
+    for h in hits:
+        out.append(f"### {h['title']} (score={h['score']})\n{h['snippet']}\n")
+    return "\n\n".join(out)
+
+def messenger_ask(history, user_text, top_k):
+    context = kb.build_context(user_text, top_k=int(top_k))
+    answer = chat.answer(user_text, context=context)
+    history = history + [(user_text, answer)]
+    return history, ""
+
+def messenger_quick(btn, history):
+    presets = {
+        "📌 Спросить про документ": "Что в базе знаний сказано про требования к карманам/фурнитуре/посадке?",
+        "🧩 Предложить улучшение": "Предложи 5 улучшений процесса, опираясь на базу знаний и лучшие практики.",
+        "🧾 Сформулировать вопрос": "Сформулируй уточняющий вопрос для дизайнера, чтобы убрать двусмысленность."
+    }
+    return history, presets.get(btn, "")
+
+def feedback_submit(author, channel, topic, rating, message, also_telegram):
+    if not message or len(message.strip()) < 5:
+        return "⚠️ Сообщение слишком короткое."
+    saved = save_feedback(author, channel, topic, rating, message)
+    if also_telegram:
+        tg = send_feedback_to_telegram(author, channel, topic, rating, message)
+        return saved + "\n" + tg
+    return saved
+
+def build_demo():
+    with gr.Blocks(title="2MOOD Feedback Knowledge Base (Pilot)") as demo:
+        gr.Markdown("# 2MOOD Feedback Knowledge Base (Pilot)\nПилот: база знаний (PDF) + сбор обратной связи + messenger.")
+
+        with gr.Tabs():
+            with gr.Tab("📚 База знаний"):
+                with gr.Row():
+                    pdf = gr.File(label="Загрузить PDF", file_types=[".pdf"])
+                    add_btn = gr.Button("➕ Добавить в базу")
+                add_out = gr.Textbox(label="Статус загрузки", lines=2)
+
+                with gr.Row():
+                    list_btn = gr.Button("📄 Список документов")
+                    docs_out = gr.Markdown()
+
+                gr.Markdown("---")
+                query = gr.Textbox(label="Поиск по базе", placeholder="например: 'параметры кармана' / 'правки по изделию'")
+                top_k = gr.Slider(1, 10, value=5, step=1, label="Top-K")
+                search_btn = gr.Button("🔎 Найти")
+                search_out = gr.Markdown()
+
+                add_btn.click(fn=kb_add, inputs=[pdf], outputs=[add_out])
+                list_btn.click(fn=kb_list, inputs=[], outputs=[docs_out])
+                search_btn.click(fn=kb_search, inputs=[query, top_k], outputs=[search_out])
+
+            with gr.Tab("💬 2MOOD Messenger"):
+                gr.Markdown("Чат-виджет: отвечает с опорой на базу знаний (RAG).")
+                history = gr.Chatbot(label="Диалог", height=380)
+                user_text = gr.Textbox(label="Сообщение", placeholder="Напишите вопрос…")
+                with gr.Row():
+                    ask_btn = gr.Button("Отправить")
+                    k = gr.Slider(1, 8, value=4, step=1, label="Top-K контекста")
+                with gr.Row():
+                    b1 = gr.Button("📌 Спросить про документ")
+                    b2 = gr.Button("🧩 Предложить улучшение")
+                    b3 = gr.Button("🧾 Сформулировать вопрос")
+
+                ask_btn.click(fn=messenger_ask, inputs=[history, user_text, k], outputs=[history, user_text])
+                b1.click(fn=messenger_quick, inputs=[b1, history], outputs=[history, user_text])
+                b2.click(fn=messenger_quick, inputs=[b2, history], outputs=[history, user_text])
+                b3.click(fn=messenger_quick, inputs=[b3, history], outputs=[history, user_text])
+
+            with gr.Tab("📝 Обратная связь"):
+                gr.Markdown("Форма обратной связи: сохраняем в SQLite + опционально отправляем в Telegram.")
+                author = gr.Textbox(label="Автор", value="2MOOD User")
+                channel = gr.Dropdown(["Web Form", "Interview", "Telegram", "Email"], value="Web Form", label="Канал")
+                topic = gr.Dropdown(["KB", "Messenger", "Protocols", "UX", "Bug", "Feature"], value="KB", label="Тема")
+                rating = gr.Slider(1, 5, value=5, step=1, label="Оценка (1–5)")
+                message = gr.Textbox(label="Сообщение", lines=6, placeholder="Что улучшить? Что мешает? Что понравилось?")
+                also_tg = gr.Checkbox(label="Отправить копию в Telegram", value=True)
+                submit = gr.Button("✅ Отправить")
+                fb_out = gr.Textbox(label="Статус", lines=3)
+
+                submit.click(fn=feedback_submit, inputs=[author, channel, topic, rating, message, also_tg], outputs=[fb_out])
+
+    return demo

data/feedback/feedback.csv

@@ -0,0 +1 @@
+2026-02-15 04:54:12,Messenger,3,,Интерфейс Мессенджера не позволяет прикладывать фото.,,

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.44.1
+openai>=1.0.0
+pypdf>=4.0.0
+python-dotenv>=1.0.0
+requests>=2.31.0
+reportlab>=4.0.0
+huggingface_hub==0.25.2