First Commit

Prompts/prompts_social.json

@@ -0,0 +1,56 @@
+{
+  "meta": {
+    "task": "social_response",
+    "version": "1.0"
+  },
+  "modes": {
+    "zero_shot": {
+      "instruction": "Responder de forma amigable y cercana al usuario.",
+      "rules": [
+        "Responde de forma natural y amistosa, con un toque reflexivo; agrega ejemplos sencillos o analogías cortas. ",
+        "Evita sonar formal y permite algo de color humano."
+      ],
+      "output_format": "1–2 oraciones relajadas y naturales.",
+      "tone": "Amigable y entusiasta.",
+      "examples": []
+    },
+    "one_shot": {
+      "instruction": "Responder de forma amigable y cercana al usuario.",
+      "rules": [
+        "Responde de forma natural y amistosa, con un toque reflexivo; agrega ejemplos sencillos o analogías cortas. ",
+        "Evita sonar formal y permite algo de color humano."
+      ],
+      "output_format": "1–2 oraciones relajadas y naturales.",
+      "tone": "Amigable y entusiasta.",
+      "examples": [
+        {
+          "input": "¿Puedo hacerte una pregunta?",
+          "output": "¡Claro! Dime cuál es tu duda y lo resolvemos juntos."
+        }
+      ]
+    },
+    "few_shot_3": {
+      "instruction": "Responder de forma amigable y cercana al usuario.",
+      "rules": [
+        "Responde de forma natural y amistosa, con un toque reflexivo; agrega ejemplos sencillos o analogías cortas. ",
+        "Evita sonar formal y permite algo de color humano."
+      ],
+      "output_format": "1–2 oraciones relajadas y naturales.",
+      "tone": "Amigable y entusiasta.",
+      "examples": [
+        {
+          "input": "¿Cuál es el significado de la vida?",
+          "output": "Pregunta enorme; por ahora enfoquémonos en tus metas de hoy. ¿Qué te gustaría avanzar?"
+        },
+        {
+          "input": "No entiendo nada 😩",
+          "output": "Tranquilo/a, aprender toma tiempo. Dime qué parte se atoró y la vemos paso a paso."
+        },
+        {
+          "input": "¿Qué opinas del clima?",
+          "output": "No tengo sensores, pero si el clima ayuda, nos aventamos otro tema 😄."
+        }
+      ]
+    }
+  }
+}

Prompts/prompts_technical.json

@@ -0,0 +1,56 @@
+{
+  "meta": {
+    "task": "technical_definition",
+    "version": "1.0"
+  },
+  "modes": {
+    "zero_shot": {
+      "instruction": "Define con precisión.",
+      "rules": [
+        "Identifica correctamente el concepto principal mencionado en la pregunta.",
+        "Proporciona una definición canónica, exacta y concisa del concepto."
+      ],
+      "output_format": "Respuesta corta y concisa.",
+      "tone": "Directo, técnico y formal.",
+      "examples": []
+    },
+    "one_shot": {
+      "instruction": "Define con precisión.",
+      "rules": [
+        "Identifica correctamente el concepto principal mencionado en la pregunta.",
+        "Proporciona una definición canónica, exacta y concisa del concepto."
+      ],
+      "output_format": "Respuesta corta y concisa.",
+      "tone": "Directo, técnico y formal.",
+      "examples": [
+        {
+          "input": "¿Que es la tecnologia?",
+          "output": "Conjunto de teorías y de técnicas que permiten el aprovechamiento práctico del conocimiento científico."
+        }
+      ]
+    },
+  "few_shot_3": {
+      "instruction": "Define con precisión.",
+      "rules": [
+        "Identifica correctamente el concepto principal mencionado en la pregunta.",
+        "Proporciona una definición canónica, exacta y concisa del concepto."
+      ],
+      "output_format": "Respuesta corta y concisa.",
+    "tone": "Directo, técnico y formal.",
+    "examples": [
+      {
+        "input": "¿Qué es un algoritmo?",
+        "output": "Conjunto ordenado de pasos o instrucciones que permiten resolver un problema o realizar una tarea de forma sistemática."
+      },
+      {
+        "input": "¿Cómo se define la inteligencia artificial?",
+        "output": "Campo de la informática que busca crear sistemas capaces de realizar tareas que requieren inteligencia humana, como razonar, aprender o reconocer patrones."
+      },
+      {
+        "input": "Define el término base de datos.",
+        "output": "Conjunto organizado de información que se almacena y gestiona electrónicamente para facilitar su acceso, consulta y actualización."
+      }
+    ]
+  }
+  }
+}

README.md

@@ -1,20 +1,100 @@
----
-title: Mori MVP BoT
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Conversational bot for defining data processing concepts
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# 🧠 Mori: Your Friendly Data Science Assistant
+
+**Mori** is a conversational assistant trained to answer questions about data science, AI concepts, and related topics.  
+It uses a dual-response system: one technical model and one social model, allowing it to switch between factual answers and casual interactions.
+
+---
+
+# Instalación
+
+## Entorno recomendado
+
+Crea y activa un entorno virtual para aislar dependencias. Se recomienda usar la carpeta en la **raíz del proyecto** (ej. `.venv`):
+
+```bash
+# Windows (PowerShell)
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+
+# Windows (CMD)
+python -m venv .venv
+.\.venv\Scripts\activate.bat
+
+# macOS / Linux (bash/zsh)
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+## Requisitos
+- **Python** 3.10  
+- (Opcional, GPU) **NVIDIA Driver** actualizado  
+- (Opcional) **CUDA/cuDNN** a nivel sistema **solo si los necesitas**.  
+  > Si instalas PyTorch con un wheel que ya incluye CUDA (p. ej., `cu118`), no requieres el toolkit local; basta con el **driver**:
+  - pip3 install torch --index-url https://download.pytorch.org/whl/cu118
+
+## Instalación (GPU)
+
+- python -m pip install --upgrade pip
+- pip install torch --index-url https://download.pytorch.org/whl/cuXXX
+- pip install -r requirements.txt
+
+## Instalación (CPU)
+
+- python -m pip install --upgrade pip
+- pip install torch --index-url https://download.pytorch.org/whl/cpu
+- pip install -r requirements.txt
+
+
+# Uso
+
+***Es necesario utilizar el siguiente comando:***
+
+- streamlit run app.py --server.port=8501 --server.address=0.0.0.0
+
+## 🚀 Try it out!
+
+Just type your question in the input box and let Mori guide you!  
+You can ask things like:
+- *What is overfitting?*
+- *Can you explain PCA?*
+- *Tell me a data science joke!*
+- *I'm feeling tired...*
+
+---
+
+## 🛠️ How it works
+
+Mori is powered by two custom fine-tuned models based on the T5 architecture:
+- `Mori Técnico`: answers technical questions about data science and machine learning
+- `Mori Social`: replies in a friendly, supportive tone for casual conversation
+
+It uses **Streamlit** for the interface and **Hugging Face Transformers** to load and run the models.
+
+---
+
+## 📁 Project structure
+
+. ├── app.py # Streamlit app ├── requirements.txt # Required packages ├── Models/ # Fine-tuned models (Técnico + Social) └── Statistics/ # Logs generated on user interaction (not persistent)
+
+
+---
+
+## 📊 Logging
+
+All interactions are logged locally in the `Statistics/` folder as `.csv` and `.jsonl` files.  
+*Note: Hugging Face Spaces do not persist these files between restarts.*
+
+---
+
+## 👤 Author
+
+Created by **[hazutecuhtli](https://huggingface.co/hazutecuhtli)**  
+PhD in Electronic Engineering, passionate about data, modeling, and sharing knowledge.
+
+---
+
+## 💡 Future Plans
+
+- Add model explanation outputs
+- Enable user-uploaded datasets
+- Connect logs to Google Sheets for persistent stats

app_RAG_4HF.py

@@ -0,0 +1,635 @@
+#***************************************************************************
+# Mori (tech-only) — Streamlit App sin sidebar ni social, con RAG opcional
+#***************************************************************************
+import os, re, json, csv, uuid, unicodedata, faiss, random
+import numpy as np
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+
+import streamlit as st
+import datetime as dt
+from pathlib import Path
+import torch
+
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from huggingface_hub import hf_hub_download
+from sentence_transformers import SentenceTransformer  # RAG embeddings
+
+# =========================
+# Configuración general
+# =========================
+HF_TOKEN = os.environ.get("HF_TOKEN")  # Token privado (colócalo en Secrets o variable de entorno)
+RAG_REPO_ID = "tecuhtli/Mori_FAISS_Full"  # Dataset privado con mori.faiss, mori_ids.npy, mori_metas.json
+
+# =========================
+# Utilidades de texto
+# =========================
+def truncate_sentences(text: str, max_sentences: int = 4) -> str:
+    _SENT_SPLIT = re.compile(r'(?<=[\.\!\?…])\s+')
+    s = text.strip()
+    if not s:
+        return s
+    parts = _SENT_SPLIT.split(s)
+    cut = " ".join(parts[:max_sentences]).strip()
+    if cut and cut[-1] not in ".!?…":
+        cut += "."
+    return cut
+
+def _load_json_safe(path: Path, fallback: dict) -> dict:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return fallback
+
+def load_prompt_cases():
+    base = Path("Prompts")
+    tech = _load_json_safe(base / "prompts_technical.json", {"modes": {}})
+    social = _load_json_safe(base / "prompts_social.json", {"modes": {}})  # no usado, se deja por compatibilidad
+    return {"technical": tech, "social": social}
+
+def polish_spanish(s: str) -> str:
+    s = unicodedata.normalize("NFC", s).strip()
+    s = re.sub(r'\s*[\[\(]\s*Mori\s+(?:Social|T[eé]nico|T[eé]cnico)\s*[\]\)]\s*', '', s, flags=re.I)
+    fixes = [
+        (r'(?i)(^|\W)T\s+puedes(?P<p>[^\w]|$)', r'\1Tú puedes\g<p>'),
+        (r'(?i)(^|\W)T\s+(ya|eres|estas|estás|tienes|puedes)\b', r'\1Tú \2'),
+        (r'(?i)\bclaro que s(?:i|í)?\b(?P<p>[,.\!?…])?', r'Claro que sí\g<p>'),
+        (r'(?i)(^|\s)si,', r'\1Sí,'),
+        (r'(?i)(\beso\s+)s(\s+est[áa]\b)', r'\1sí\2'),
+        (r'(?i)(^|[\s,;:])s(\s+es\b)', r'\1sí\2'),
+        (r'(?i)\btiles\b', 'útiles'),
+        (r'(?i)\butiles\b', 'útiles'),
+        (r'(?i)\butil\b', 'útil'),
+        (r'(?i)\baqui\b', 'aquí'),
+        (r'(?i)\balgn\b', 'algún'),
+        (r'(?i)\bAnimo\b', 'Ánimo'),
+        (r'(?i)\baprendisaje\b', 'aprendizaje'),
+        (r'(?i)\bmanana\b', 'mañana'),
+        (r'(?i)\benergia\b', 'energía'),
+        (r'(?i)\bextrano\b', 'extraño'),
+        (r'(?i)\bextrana\b', 'extraña'),
+        (r'(?i)\bextranar\b', 'extrañar'),
+        (r'(?i)\bextranarte\b', 'extrañarte'),
+        (r'(?i)\bextranas\b', 'extrañas'),
+        (r'(?i)\bextranos\b', 'extraños'),
+        (r'(?i)\bestare\b', 'estaré'),
+        (r'(?i)\bclarin\b', 'clarín'),
+        (r'(?i)\bclar[íi]n\s+cornetas\b', 'clarín cornetas'),
+        (r'(?i)(^|\s)s([,.;:!?])', r'\1Sí\2'),
+        (r'(?i)\bfutbol\b', 'fútbol'),
+        (r'(?i)(^|\s)as(\s+se\b)', r'\1Así\2'),
+        (r'(?i)\bbuen dia\b', 'buen día'),
+        (r'(?i)\bgran dia\b', 'gran día'),
+        (r'(?i)\bdias\b', 'días'),
+        (r'(?i)\bdia\b', 'día'),
+        (r'(?i)\bacompa?a(r|rte|do|da|dos|das)?\b', r'acompaña\1'),
+        (r'(?i)(^|\s)S lo se\b', r'\1Sí lo sé'),
+        (r'(?i)\bcuidate\b', 'cuídate'),
+        (r'(?i)\bcuidese\b', 'cuídese'),
+        (r'(?i)\bcuidense\b', 'cuídense'),
+        (r'(?i)\bgracias por confiar en m\b', 'gracias por confiar en mí'),
+        (r'(?i)\bcada dia\b', 'cada día'),
+        (r'(?i)\bsegun\b', 'según'),
+        (r'(?i)\bcaracteristica(s)?\b', r'característica\1'),
+        (r'(?i)\bcaracterstica(s)?\b', r'característica\1'),
+        (r'(?i)\b([a-záéíóúñ]+)cion\b', r'\1ción'),
+        (r'(?i)\bdeterminacio\b', 'determinación'),
+    ]
+    for pat, rep in fixes:
+        s = re.sub(pat, rep, s)
+    s = re.sub(r'(?i)^eso es todo!(?P<r>(\s|$).*)', r'¡Eso es todo!\g<r>', s)
+    s = re.sub(r'\s+', ' ', s).strip()
+    if s and s[-1] not in ".!?…":
+        s += "."
+    return s
+
+def normalize_for_route(s: str) -> str:
+    s = unicodedata.normalize("NFKD", s)
+    s = "".join(ch for ch in s if not unicodedata.combining(ch))
+    s = re.sub(r"[^\w\s-]", " ", s, flags=re.UNICODE)
+    s = re.sub(r"\s+", " ", s).strip().lower()
+    return s
+
+def anti_echo(response: str, user_text: str) -> str:
+    rn = normalize_for_route(response)
+    un = normalize_for_route(user_text)
+    def _clean_leading(s: str) -> str:
+        s = re.sub(r'^\s*[,;:\-–—]\s*', '', s)
+        s = re.sub(r'^\s+', '', s)
+        return s
+    if len(un) >= 4 and rn.startswith(un):
+        cut = re.sub(r'^\s*[^,;:\.\!\?]{0,120}[,;:\-]\s*', '', response).lstrip()
+        if cut and cut != response:
+            return _clean_leading(cut)
+        return _clean_leading(response[len(user_text):])
+    return response
+
+# =========================
+# Prompting técnico
+# =========================
+def build_prompt_from_cases(domain: str,
+                            prompt_type: str,
+                            persona: str,
+                            question: str,
+                            context: str | None = None) -> str:
+    key_map = {
+        "Zero-shot": "zero_shot",
+        "One-shot": "one_shot",
+        "Few-shot (3)": "few_shot_3"
+    }
+    mode_key = key_map.get(prompt_type, "zero_shot")
+    data = st.session_state.PROMPT_CASES.get(domain, {}).get("modes", {}).get(mode_key, {})
+
+    tone = data.get("tone", "")
+    out_fmt = data.get("output_format", "")
+    rules = "\n- ".join(data.get("rules", []))
+    ctx_line = f"\n- Contexto: {context}" if context else ""
+
+    # ejemplos si hay
+    examples = data.get("examples", [])
+    ex_str = ""
+    if examples:
+        parts = []
+        for i, ex in enumerate(examples, 1):
+            parts.append(f"Ejemplo {i} →\nPregunta: {ex.get('input','')}\nRespuesta: {ex.get('output','')}")
+        ex_str = "\n\n" + "\n\n".join(parts) + "\n\nAhora responde:"
+
+    # prompt final (siempre técnico)
+    prompt = (
+        f"Tarea: {data.get('instruction','Responde como asistente técnico en procesamiento de datos.')}\n"
+        f"Reglas:\n- {rules}{ctx_line}\n"
+        f"Estilo: {tone}\n"
+        f"Formato de salida: {out_fmt}\n"
+        f"{ex_str}\n"
+        f"pregunta={question}\n"
+    )
+    return prompt.strip()
+
+def set_seeds(seed: int = 42):
+    random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+# =========================
+# RAG helpers
+# =========================
+@st.cache_resource
+def load_rag_assets(device_str: str = "cpu"):
+    """
+    Carga E5 + FAISS + metadatos desde Hugging Face (dataset privado).
+    """
+    token = os.getenv("HF_TOKEN")
+    if not token:
+        st.warning("⚠️ No se encontró HF_TOKEN; RAG no estará disponible.")
+        return None, None, None
+
+    try:
+        faiss_path = hf_hub_download(repo_id=RAG_REPO_ID, filename="mori.faiss", repo_type="dataset", token=token)
+        ids_path   = hf_hub_download(repo_id=RAG_REPO_ID, filename="mori_ids.npy", repo_type="dataset", token=token)
+        meta_path  = hf_hub_download(repo_id=RAG_REPO_ID, filename="mori_metas.json", repo_type="dataset", token=token)
+
+        index = faiss.read_index(faiss_path)
+        _ = np.load(ids_path, allow_pickle=True)  # ids no usados explícitamente, se conserva por consistencia
+        with open(meta_path, "r", encoding="utf-8") as f:
+            metas = json.load(f)
+
+        e5 = SentenceTransformer("intfloat/multilingual-e5-base", device=device_str)
+        st.info(f"✅ RAG cargado con {index.ntotal} vectores.")
+        return e5, index, metas
+    except Exception as e:
+        st.error(f"❌ Error al cargar RAG: {e}")
+        return None, None, None
+
+def rag_retrieve(e5, index, metas, user_text: str, k: int = 5):
+    if e5 is None or index is None or metas is None or index.ntotal == 0:
+        return []
+    qv = e5.encode([f"query: {user_text}"], normalize_embeddings=True,
+                   convert_to_numpy=True).astype("float32")
+    k = max(1, min(int(k), index.ntotal))
+    scores, idxs = index.search(qv, k)
+    out = []
+    for rank, (s, i) in enumerate(zip(scores[0], idxs[0]), 1):
+        if i == -1:
+            continue
+        m = metas[i]
+        out.append({
+            "rank": rank, "score": float(s),
+            "id": m.get("id",""),
+            "canonical_term": m.get("canonical_term",""),
+            "context": m.get("context",""),
+            "input": m.get("input",""),
+            "output": m.get("output",""),
+        })
+    return out
+
+def build_rag_prompt_technical(base_prompt: str, user_text: str, passages):
+    ev_lines = []
+    for p in passages:
+        ev_lines.append(
+            f"[{p['rank']}] term='{p.get('canonical_term','')}' ctx='{p.get('context','')}'\n"
+            f"input: {p.get('input','')}\n"
+            f"output: {p.get('output','')}"
+        )
+    ev_block = "\n".join(ev_lines)
+    rag_rules = (
+        "\n\n[ Modo RAG ]\n"
+        "- Usa EXCLUSIVAMENTE la información relevante de las evidencias.\n"
+        "- Si algo no aparece en las evidencias, dilo explícitamente.\n"
+        "- Cita las evidencias con [n] (ej. [1], [3]).\n"
+    )
+    return f"{base_prompt.strip()}\n{rag_rules}\nEVIDENCIAS:\n{ev_block}\n"
+
+def get_bad_words_ids(tok):
+    bad = []
+    for sym in ["[", "]"]:
+        ids = tok.encode(sym, add_special_tokens=False)
+        if ids and all(isinstance(t, int) and t >= 0 for t in ids):
+            bad.append(ids)
+    return bad
+
+# =========================
+# Generación técnica
+# =========================
+def technical_asnwer(question, context, model, tokenizer, device, gen_params=None):
+    model = model.to(device).eval()
+
+    persona_name = (gen_params or {}).get("persona", st.session_state.get("persona", "Mori Normal"))
+    prompt_type  = st.session_state.get("prompt_type", "Zero-shot")
+
+    input_text = build_prompt_from_cases(
+        domain="technical",
+        prompt_type=prompt_type,
+        persona=persona_name,
+        question=question,
+        context=context
+    )
+
+    st.session_state["last_prompt"] = input_text
+    st.session_state["just_generated"] = True
+
+    enc = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
+
+    bad_words = ["["]
+    bad_ids = [tokenizer(bw, add_special_tokens=False).input_ids for bw in bad_words]
+
+    max_new   = int((gen_params or {}).get("max_new_tokens", 128))
+    min_new   = int((gen_params or {}).get("min_tokens", 16))
+    no_repeat = int((gen_params or {}).get("no_repeat_ngram_size", 3))
+    rep_pen   = float((gen_params or {}).get("repetition_penalty", 1.0))
+    mode      = (gen_params or {}).get("mode", "beam")
+
+    eos_id = tokenizer.eos_token_id or tokenizer.convert_tokens_to_ids("</s>")
+    pad_id = tokenizer.pad_token_id or eos_id
+
+    if mode == "sampling":
+        temperature = float((gen_params or {}).get("temperature", 0.8))
+        top_p       = float((gen_params or {}).get("top_p", 0.9))
+        kwargs = dict(
+            do_sample=True, num_beams=1,
+            temperature=max(0.1, temperature),
+            top_p=min(1.0, max(0.5, top_p)),
+            max_new_tokens=max_new,
+            min_new_tokens=max(0, min_new),
+            no_repeat_ngram_size=no_repeat,
+            repetition_penalty=max(1.0, rep_pen),
+            bad_words_ids=bad_ids,
+            eos_token_id=eos_id,
+            pad_token_id=pad_id,
+        )
+    else:
+        num_beams      = max(2, int((gen_params or {}).get("num_beams", 4)))
+        length_penalty = float((gen_params or {}).get("length_penalty", 1.0))
+        kwargs = dict(
+            do_sample=False, num_beams=num_beams, length_penalty=length_penalty,
+            max_new_tokens=max_new,
+            min_new_tokens=max(0, min_new),
+            no_repeat_ngram_size=no_repeat,
+            repetition_penalty=max(1.0, rep_pen),
+            bad_words_ids=bad_ids,
+            eos_token_id=eos_id,
+            pad_token_id=pad_id,
+        )
+
+    out_ids = model.generate(
+        input_ids=enc["input_ids"], attention_mask=enc["attention_mask"], **kwargs
+    )
+    text = tokenizer.decode(out_ids[0], skip_special_tokens=True)
+
+    if persona_name == "Mori Normal":
+        text = truncate_sentences(text, max_sentences=1)
+
+    st.session_state["last_response"] = text
+    return polish_spanish(text)
+
+def technical_answer_rag(
+    question, tec_model, tec_tok, device, gen_params,
+    e5, index, metas, k=5, sim_threshold=0.40
+):
+    passages = rag_retrieve(e5, index, metas, question, k=k)
+    if not passages:
+        return "No encontré evidencias relevantes para responder con certeza. ¿Puedes dar más contexto?"
+
+    persona_name = (gen_params or {}).get("persona", st.session_state.get("persona", "Mori Normal"))
+    _ = st.session_state.get("prompt_type", "Zero-shot")  # guardado por compatibilidad
+
+    base_prompt = build_prompt_from_cases(
+        domain="technical",
+        prompt_type="Zero-shot",
+        persona=persona_name,
+        question=question,
+        context="RAG"
+    )
+
+    prompt = build_rag_prompt_technical(base_prompt, question, passages)
+
+    max_sim = passages[0]["score"]
+    if max_sim < sim_threshold:
+        prompt = "⚠️ Baja similitud con la base; podría faltar contexto.\n\n" + prompt
+    st.session_state["last_prompt"] = prompt
+    st.session_state["just_generated"] = True
+
+    enc = tec_tok(prompt, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
+
+    bad_ids = get_bad_words_ids(tec_tok)
+
+    max_new   = int((gen_params or {}).get("max_new_tokens", 128))
+    min_new   = int((gen_params or {}).get("min_tokens", 16))
+    no_repeat = int((gen_params or {}).get("no_repeat_ngram_size", 3))
+    rep_pen   = float((gen_params or {}).get("repetition_penalty", 1.0))
+    mode      = (gen_params or {}).get("mode", "beam")
+
+    eos_id = tec_tok.eos_token_id or tec_tok.convert_tokens_to_ids("</s>")
+    pad_id = tec_tok.pad_token_id or eos_id
+
+    if mode == "sampling":
+        temperature = float((gen_params or {}).get("temperature", 0.8))
+        top_p       = float((gen_params or {}).get("top_p", 0.9))
+        kwargs = dict(
+            do_sample=True, num_beams=1,
+            temperature=max(0.1, temperature),
+            top_p=min(1.0, max(0.5, top_p)),
+            max_new_tokens=max_new,
+            min_new_tokens=max(0, min_new),
+            no_repeat_ngram_size=no_repeat,
+            repetition_penalty=max(1.0, rep_pen),
+            eos_token_id=eos_id,
+            pad_token_id=pad_id,
+        )
+    else:
+        num_beams      = max(2, int((gen_params or {}).get("num_beams", 4)))
+        length_penalty = float((gen_params or {}).get("length_penalty", 1.0))
+        kwargs = dict(
+            do_sample=False, num_beams=num_beams, length_penalty=length_penalty,
+            max_new_tokens=max_new,
+            min_new_tokens=max(0, min_new),
+            no_repeat_ngram_size=no_repeat,
+            repetition_penalty=max(1.0, rep_pen),
+            eos_token_id=eos_id,
+            pad_token_id=pad_id,
+        )
+
+    if bad_ids:
+        kwargs["bad_words_ids"] = bad_ids
+
+    out_ids = tec_model.generate(**enc, **kwargs)
+    text = tec_tok.decode(out_ids[0], skip_special_tokens=True)
+
+    if persona_name == "Mori Normal":
+        text = truncate_sentences(text, max_sentences=1)
+    text = polish_spanish(text)
+
+    st.session_state["last_response"] = text
+    return text
+
+# =========================
+# Persistencia simple
+# =========================
+def saving_interaction(question, response, context, user_id):
+    timestamp = dt.datetime.now().isoformat()
+    stats_dir = Path("Statistics")
+    stats_dir.mkdir(parents=True, exist_ok=True)
+
+    archivo_csv = stats_dir / "conversaciones_log.csv"
+    existe_csv = archivo_csv.exists()
+
+    with open(archivo_csv, mode="a", encoding="utf-8", newline="") as f_csv:
+        writer = csv.writer(f_csv)
+        if not existe_csv:
+            writer.writerow(["timestamp", "user_id", "contexto", "pregunta", "respuesta"])
+        writer.writerow([timestamp, user_id, context, question, response])
+
+    archivo_jsonl = stats_dir / "conversaciones_log.jsonl"
+    with open(archivo_jsonl, mode="a", encoding="utf-8") as f_jsonl:
+        registro = {
+            "timestamp": timestamp,
+            "user_id": user_id,
+            "context": context,
+            "pregunta": question,
+            "respuesta": response
+        }
+        f_jsonl.write(json.dumps(registro, ensure_ascii=False) + "\n")
+
+# =========================
+# Enrutador técnico único
+# =========================
+def answer_technical_only(user_text: str, device, gen_params,
+                          tec_model, tec_tok):
+    # Intentar RAG si está activado
+    use_rag = st.session_state.get("use_rag", True)
+    if use_rag:
+        e5, index, metas = load_rag_assets("cuda" if torch.cuda.is_available() else "cpu")
+        if e5 is not None and index is not None and index.ntotal > 0:
+            return technical_answer_rag(
+                user_text, tec_model, tec_tok, device, gen_params,
+                e5=e5, index=index, metas=metas,
+                k=st.session_state.get("rag_k", 3), sim_threshold=0.40
+            )
+    # Fallback sin RAG
+    return technical_asnwer(
+        question=user_text,
+        context="procesamiento de datos",
+        model=tec_model, tokenizer=tec_tok, device=device,
+        gen_params=gen_params
+    )
+
+# =========================
+# MAIN
+# =========================
+if __name__ == '__main__':
+    # Estado persistente
+    ss = st.session_state
+    ss.setdefault("historial", [])
+    ss.setdefault("last_prompt", "")
+    ss.setdefault("last_response", "")
+    ss.setdefault("just_generated", False)
+
+    # Prompt cases y presets (sin sidebar)
+    if "PROMPT_CASES" not in ss:
+        ss.PROMPT_CASES = load_prompt_cases()
+
+    ss.setdefault("persona", "Mori Normal")
+    ss.setdefault("prompt_type", "Zero-shot")
+    ss.setdefault("use_rag", True)
+    ss.setdefault("rag_k", 3)
+
+    GEN_PARAMS = {
+        "persona": ss.get("persona", "Mori Normal"),
+        "mode": "beam",                 # 'beam' | 'sampling'
+        "max_new_tokens": 128,
+        "min_tokens": 16,
+        "no_repeat_ngram_size": 3,
+        "num_beams": 4,
+        "length_penalty": 1.0,
+        "temperature": 0.8,             # usado solo si mode == "sampling"
+        "top_p": 0.9,                   # usado solo si mode == "sampling"
+        "repetition_penalty": 1.0,
+        "seed": 42,
+    }
+
+    # ID de sesión
+    if "user_id" not in ss:
+        ss["user_id"] = str(uuid.uuid4())[:8]
+
+    # Carga del modelo técnico
+    tec_tok = AutoTokenizer.from_pretrained("tecuhtli/mori-tecnico-model", use_auth_token=HF_TOKEN)
+    tec_model = AutoModelForSeq2SeqLM.from_pretrained("tecuhtli/mori-tecnico-model", use_auth_token=HF_TOKEN)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Presentación (solo técnico)
+    st.title("🤖 Mori — Asistente Técnico en Procesamiento de Datos")
+    st.caption("🙋🏽‍ Pregunta sobre: limpieza, features, evaluación, modelos, MLOps, BI, visualización, etc.")
+    st.caption("➡️ Ejemplos: Define X, ¿Para qué sirve Y?, Explícame Z, Diferencia entre A y B, ¿Cómo implemento ...?")
+    st.markdown("<br>", unsafe_allow_html=True)
+    st.caption("✏️ Escribe 'salir' para terminar.")
+
+    # Limpieza previa del textarea si corresponde
+    if ss.pop("_clear_entrada", False):
+        if "entrada" in ss:
+            del ss["entrada"]
+
+    # Respuesta flash de ciclo anterior
+    _flash = ss.pop("_flash_response", None)
+
+    # Formulario
+    with st.form("formulario_mori"):
+        user_question = st.text_area("📝 Escribe tu pregunta aquí", key="entrada", height=100)
+        submitted = st.form_submit_button("Responder")
+
+    if submitted:
+        if not user_question:
+            st.info("Mori: ¿Podrías repetir eso? No entendí bien 😅")
+        else:
+            response = answer_technical_only(user_question, device, GEN_PARAMS, tec_model, tec_tok)
+
+            # Historial
+            hora_actual = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            ss.historial.append(("Tú", user_question, hora_actual))
+            hora_actual = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            ss.historial.append(("Mori", response, hora_actual))
+
+            # Guardado persistente
+            saving_interaction(user_question, response, "procesamiento de datos", ss["user_id"])
+
+            # Flash y limpieza
+            ss["_flash_response"] = response
+            ss["_clear_entrada"] = True
+            st.rerun()
+
+    # Mostrar respuesta flash
+    if _flash:
+        st.success(_flash)
+
+    # Historial + descarga
+    if ss.historial:
+        st.markdown("---")
+
+        lineas = []
+        for msg in reversed(ss.historial):
+            if len(msg) == 3:
+                autor, texto, hora = msg
+                lineas.append(f"[{hora}] {autor}: {texto}")
+            else:
+                autor, texto = msg
+                lineas.append(f"{autor}: {texto}")
+        texto_chat = "\n\n".join(lineas)
+
+        st.download_button(
+            label="💾 Descargar conversación como .txt",
+            data=texto_chat,
+            file_name="conversacion_mori.txt",
+            mime="text/plain",
+            use_container_width=True
+        )
+
+        # Contenedor con estilo
+        st.markdown(
+            """
+            <div id="chat-container" style="
+                max-height: 400px;
+                overflow-y: auto;
+                padding: 10px;
+                border: 1px solid #333;
+                border-radius: 10px;
+                background: linear-gradient(180deg, #0e0e0e 0%, #1b1b1b 100%);
+                margin-top: 10px;
+            ">
+            """,
+            unsafe_allow_html=True
+        )
+
+        for msg in reversed(ss.historial):
+            if len(msg) == 3:
+                autor, texto, _ = msg
+            else:
+                autor, texto = msg
+
+            if autor == "Tú":
+                st.markdown(
+                    f"""
+                    <div style="
+                        text-align: right;
+                        background-color: #2d2d2d;
+                        color: #e6e6e6;
+                        padding: 10px 14px;
+                        border-radius: 12px;
+                        margin: 6px 0;
+                        border: 1px solid #3a3a3a;
+                        display: inline-block;
+                        max-width: 80%;
+                        float: right;
+                        clear: both;
+                    ">
+                        🧍‍♂️ <b>{autor}:</b> {texto}
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+            else:
+                st.markdown(
+                    f"""
+                    <div style="
+                        text-align: left;
+                        background-color: #162b1f;
+                        color: #d9ead3;
+                        padding: 10px 14px;
+                        border-radius: 12px;
+                        margin: 6px 0;
+                        border: 1px solid #264d36;
+                        display: inline-block;
+                        max-width: 80%;
+                        float: left;
+                        clear: both;
+                    ">
+                        🤖 <b>{autor}:</b> {texto}
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+
+        st.markdown("</div>", unsafe_allow_html=True)
+#***************************************************************************
+# FIN
+#***************************************************************************

requirements.txt

@@ -1,3 +1,9 @@
-altair
-pandas
-streamlit
+# Core dependencies
+transformers>=4.41,<4.44
+tokenizers>=0.15.2,<0.20
+safetensors>=0.4.2
+sentencepiece>=0.1.99
+streamlit>=1.33,<2.0
+numpy>=1.24
+joblib>=1.3
+Unidecode>=1.3