Actualización del modelo / README / pesos / etc.

Prompts/prompts_social.json

@@ -1,56 +0,0 @@
-{
-  "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

@@ -1,56 +0,0 @@
-{
-  "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

@@ -10,12 +10,12 @@ pinned: false
 license: mit
 ---
 
-# 🧠 Mori: Your Friendly Data Science Assistant
+# 🧠 Your Friendly Data Science Assistant
 
 
-# 🧠 Mori: Your Friendly Data Science Assistant
+# 🧠 Your Friendly Data Science Assistant
 
-**Mori** is a conversational assistant trained to answer questions about data science, AI concepts, and related topics.  
+**This Assistant** is a conversational assistant trained to answer questions about data science, AI concepts, and related topics.  
 It now runs **tech-only**: just the technical model + optional RAG (FAISS on HF), no social model, no classifier.
 
 ---

app.py

@@ -18,22 +18,182 @@ 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
-# =========================
+#***************************************************************************
+# Sidebar controls for generation params
+#***************************************************************************
+
+def sidebar_params():
+    
+    with st.sidebar:
+        st.title("🎮 Adjustments (T5-Base)")
+
+        ss = st.session_state
+        # Defaults (solo 1ª vez)
+
+        # Estado inicial: ocultar ajustes avanzados
+        ss = st.session_state
+        if "show_llm_controls" not in ss:
+            ss.show_llm_controls = False
+
+        
+        ss.setdefault("persona", "Normal")
+        ss.setdefault("mode", "beam")  # 'beam' | 'sampling'
+        ss.setdefault("max_new", 128)
+        ss.setdefault("min_tok", 16)
+        ss.setdefault("no_repeat", 3)
+        ss.setdefault("num_beams", 4)
+        ss.setdefault("length_penalty", 1.0)
+        ss.setdefault("temperature", 0.7)
+        ss.setdefault("top_p", 0.9)
+        ss.setdefault("repetition_penalty", 1.0)
+        ss.setdefault("show_llm_controls", True)  # Toggle principal
+
+        # ----------------------------
+        # Personalidad (presets)
+        # ----------------------------
+        st.header("💡 Predefined Personalities")
+        c1, c2 = st.columns(2)
+
+        with c1:
+            if st.button("Normal 🧐", use_container_width=True):
+                ss.update({
+                    "persona": "Normal",
+                    "mode": "beam",
+                    "num_beams": 1,
+                    "max_new": 92,
+                    "min_tok": 32,
+                    "no_repeat": 3,
+                    "length_penalty": .3,
+                    "temperature": 0.4,
+                    "top_p": 0.9,
+                    "repetition_penalty": .4,
+                })
+                st.rerun()
+
+        with c2:
+            if st.button("Enthusiastic 😃", use_container_width=True):
+                ss.update({
+                    "persona": "Enthusiastic",   # <- corregido
+                    "mode": "sampling",
+                    "max_new": 192,
+                    "min_tok": 48,
+                    "no_repeat": 3,
+                    "temperature": .8,
+                    "top_p": 0.95,
+                    "repetition_penalty": 1.0,
+                })
+                st.rerun()
+
+        st.caption(f"Selected Personality: **{ss.persona}**")
+
+        # ----------------------------
+        # Botón para mostrar/ocultar parámetros
+        # ----------------------------
+        if st.button(("🔼 Hide" if ss.show_llm_controls else "🔽 Show") + " Advanced Settings"):
+            ss.show_llm_controls = not ss.show_llm_controls
+            st.rerun()
+
+        # ----------------------------
+        # Controles del modelo (sliders, estrategia, etc.)
+        # ----------------------------
+        if ss.show_llm_controls:
+            st.header("⚙️ Manual Adjustments")
+            st.subheader("📝 Text Generation")
+            picked = st.radio(
+                "Strategy",
+                ["Beam search (stable)", "Sampling (creative)"],
+                index=0 if ss.mode == "beam" else 1,
+                help="https://huggingface.co/docs/transformers/generation_strategies"
+            )
+            ss.mode = "beam" if picked.startswith("Beam") else "sampling"
+
+            st.subheader("🔧 LLM text generation parameters")
+            ss.max_new = st.slider(
+                "max_new_tokens", 16, 256, int(ss.max_new), step=8,
+                help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+            )
+            ss.min_tok = st.slider(
+                "min_tokens", 0, int(ss.max_new), int(ss.min_tok),
+                help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+            )
+            ss.no_repeat = st.slider(
+                "no_repeat_ngram_size", 0, 6, int(ss.no_repeat),
+                help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+            )
+
+            # Subcontroles según modo
+            if ss.mode == "beam":
+                ss.num_beams = st.slider(
+                    "num_beams", 2, 8, int(ss.num_beams),
+                    help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+                )
+                ss.length_penalty = st.slider(
+                    "length_penalty", 0.0, 2.0, float(ss.length_penalty),
+                    step=0.1, help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+                )
+            else:
+                ss.temperature = st.slider(
+                    "temperature", 0.1, 1.5, float(ss.temperature),
+                    step=0.05, help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+                )
+                ss.top_p = st.slider(
+                    "top_p", 0.5, 1.0, float(ss.top_p),
+                    step=0.01, help="https://huggingface.co/docs/transformers/main_classes/text_generation"
+                )
+
+       
+        if "last_prompt" in st.session_state and st.session_state["last_prompt"]:
+            with st.expander("Show generated prompt"):
+                st.text_area(
+                    "Prompt actual:",
+                    st.session_state["last_prompt"],
+                    height=200,
+                    disabled=True
+                )
+        else:
+            st.caption("👉 No prompt is available yet.")        
+
+        # ----------------------------
+        # Construir diccionario de parámetros
+        # ----------------------------
+        params = {
+            "persona": ss.persona,
+            "mode": ss.mode,
+            "max_new_tokens": int(ss.max_new),
+            "min_tokens": int(ss.min_tok),
+            "no_repeat_ngram_size": int(ss.no_repeat),
+            "repetition_penalty": float(ss.repetition_penalty),
+        }
+        if ss.mode == "beam":
+            params.update({
+                "num_beams": int(ss.num_beams),
+                "length_penalty": float(ss.length_penalty),
+            })
+        else:
+            params.update({
+                "temperature": float(ss.temperature),
+                "top_p": float(ss.top_p),
+            })
+
+        return params
+
+
+#***************************************************************************
+# Functions
+#***************************************************************************
+
+
 def truncate_sentences(text: str, max_sentences: int = 4) -> str:
     _SENT_SPLIT = re.compile(r'(?<=[\.\!\?…])\s+')
     s = text.strip()
-    if not s:
-        return s
+    if not s: return s
     parts = _SENT_SPLIT.split(s)
     cut = " ".join(parts[:max_sentences]).strip()
-    if cut and cut[-1] not in ".!?…":
-        cut += "."
+    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:
@@ -41,15 +201,61 @@ def _load_json_safe(path: Path, fallback: dict) -> dict:
     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}
+# Function to clean the question field
+def limpiar_input():
+    st.session_state["entrada"] = ""
+
+# ✅ Corrige la ruta correctamente desde Scripts hacia Models
+def get_model_path(folder_name):
+    return Path("Models") / folder_name
+
+# Function to save user interaction
+def saving_interaction(question, response, context, user_id):
+    '''
+    inputs:
+    question --> User input question
+    response --> Assistant response to the user question
+    context --> Context related to the user input, found by the trained classifier
+    user_id --> ID for the current user (Unique ID per session)
+    '''
+    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")
+
+# Function to load models within the huggingface repositories space
+@st.cache_resource
+def load_model(path_str):
+    path = Path(path_str).resolve()
+    tokenizer = AutoTokenizer.from_pretrained(path, local_files_only=True)
+    model = AutoModelForSeq2SeqLM.from_pretrained(path, local_files_only=True)
+    return model, tokenizer
+
+#-------------------------------------------------------------------------
+# Function to correct Spanish sentences' punctuation and missing characters
+#-------------------------------------------------------------------------
 
 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)
+    s = re.sub(r'\s*[\[\(]\s*Assistant\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'),
@@ -61,34 +267,67 @@ def polish_spanish(s: str) -> str:
         (r'(?i)\butiles\b', 'útiles'),
         (r'(?i)\butil\b', 'útil'),
         (r'(?i)\baqui\b', 'aquí'),
+        (r'(?i)\baqu\b(?=\s+estoy\b)', 'aquí'),
         (r'(?i)\balgn\b', 'algún'),
+        (r'(?i)\balgun\b', 'algún'),
         (r'(?i)\bAnimo\b', 'Ánimo'),
+        (r'(?i)\bcario\b', 'cariño'),
         (r'(?i)\baprendisaje\b', 'aprendizaje'),
         (r'(?i)\bmanana\b', 'mañana'),
+        (r'(?i)\bmaana\b', 'mañana'),
         (r'(?i)\benergia\b', 'energía'),
+        (r'(?i)\benerga\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)\baqu\b', 'aquí'),
+        (r'(?i)\baqui\b', 'aquí'),
         (r'(?i)\bestare\b', 'estaré'),
+        (r'(?i)\bclarn\b', 'clarín'),
         (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)(^|\s)s(\s+orientarte\b)', r'\1sí\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)\bgran da\b', 'gran día'),
         (r'(?i)\bacompa?a(r|rte|do|da|dos|das)?\b', r'acompaña\1'),
+        (r'(?i)(^|\s)as([,.;:!?]|\s|$)', r'\1así\2'),
         (r'(?i)(^|\s)S lo se\b', r'\1Sí lo sé'),
+        (r'(?i)(^|\s)S lo sé\b', r'\1Sí lo sé'),
+        (r'(?i)\bcudese\b', 'cuídese'),
+        (r'(?i)\bpequeo\b', 'pequeño'),
+        (r'(?i)\bpequea\b', 'pequeña'),
+        (r'(?i)\bpequeos\b', 'pequeños'),
+        (r'(?i)\bpequeas\b', 'pequeñas'),
+        (r'(?i)\bunico\b', 'único'),
+        (r'(?i)\bunica\b', 'única'),
+        (r'(?i)\bunicos\b', 'únicos'),
+        (r'(?i)\bunicas\b', 'únicas'),
+        (r'(?i)\bnico\b', 'único'),
+        (r'(?i)\bnica\b', 'única'),
+        (r'(?i)\bnicos\b', 'únicos'),
+        (r'(?i)\bnicas\b', 'únicas'),
+        (r'(?i)\bestadstico\b', 'estadístico'),
+        (r'(?i)\bestadstica\b', 'estadística'),
+        (r'(?i)\bestadsticos\b', 'estadísticos'),
+        (r'(?i)\bestadsticas\b', 'estadísticas'),
+        (r'(?i)\bcudate\b', 'cuídate'),
         (r'(?i)\bcuidate\b', 'cuídate'),
         (r'(?i)\bcuidese\b', 'cuídese'),
+        (r'(?i)\bcudese\b', 'cuídese'),
         (r'(?i)\bcuidense\b', 'cuídense'),
+        (r'(?i)\bcudense\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)\bcada da\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'),
@@ -97,18 +336,30 @@ def polish_spanish(s: str) -> str:
     ]
     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)
+
+    def add_opening_q(m):
+        cuerpo = m.group('qbody')
+        if '¿' in cuerpo:
+            return m.group(0)
+        return f"{m.group('pre')}¿{cuerpo}"
+    s = re.sub(r'(?P<pre>(^|[\.!\…]\s+))(?P<qbody>[^?]*\?)', add_opening_q, s)
+
+    def _open_exclam(m):
+        palabra = m.group('w')
+        resto   = m.group('r') or ''
+        return f'¡{palabra}!{resto}'
+    s = re.sub(r'(?i)^(?P<w>(hola|gracias|genial|perfecto|claro|por supuesto|con gusto|listo|vaya|wow|tu puedes|tú puedes|clarín|clarin|clarín cornetas))!(?P<r>(\s|$).*)',_open_exclam, 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
+#-------------------------------------------------------------------------
+# Function to remove repeated input in the Model answer
+#-------------------------------------------------------------------------
 
 def anti_echo(response: str, user_text: str) -> str:
     rn = normalize_for_route(response)
@@ -124,192 +375,198 @@ def anti_echo(response: str, user_text: str) -> str:
         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"
+#-------------------------------------------------------------------------
+# Normalization helpers
+#-------------------------------------------------------------------------
+
+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
+
+_Q_STARTERS = {
+    "como","que","quien","quienes","cuando","donde","por que","para que",
+    "cual","cuales","cuanto","cuantos","cuanta","cuantas"
+}
+_EXC_TRIGGERS = {"motiva","motivame","animate","animame","animo","ayudame","ayudame porfa", "clarin", "clarín", "clarinete", "clarin cornetas"}
+SPECIAL_NOPUNCT = {"kiubo", "quiubo", "que chido", "qué chido", "que buena onda"}
+_Q_VERB_STARTERS = {"eres","estas","estás","puedes","sabes","tienes","quieres","conoces",
+        "crees","piensas","dirias","dirías","podrias","podrías","podras","podrás"}
+
+#-------------------------------------------------------------------------
+# Punctuation helpers
+#-------------------------------------------------------------------------
+
+def needs_question_marks(norm: str) -> bool:
+    if "?" in norm: return False
+    for w in _Q_STARTERS:
+        if norm.startswith(w + " ") or norm == w:
+            return True
+    return False
+
+def needs_exclam(norm: str) -> bool:
+    if "!" in norm: return False
+    return any(t in norm for t in _EXC_TRIGGERS)
+
+#-------------------------------------------------------------------------
+# Greetings detection
+#-------------------------------------------------------------------------
+
+def is_slang_greeting(norm: str) -> bool:
+    SHORT = {
+        "que pex", "que onda", "ke pex", "k pex", "q onda",
+        "kiubo", "quiubo", "quiubole", "quiúbole", "kionda", "q onda", "k onda",
+        "que rollo", "ke onda", "que show", "que tranza"
     }
-    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()
+    if norm in SHORT: return True
+    if re.match(r"^(q|k|ke|que)\s+(pex|onda|rollo|show|tranza)\b", norm): return True
+    if re.match(r"^(kiubo|quiubo|quiubole|quiúbole|quiubol[e]?)\b", norm): return True
+    return False
+
+#-------------------------------------------------------------------------
+# Capitalization & autopunct
+#-------------------------------------------------------------------------
+
+def capitalize_spanish(s: str) -> str:
+    s = s.strip()
+    i = 0
+    while i < len(s) and not s[i].isalpha():
+        i += 1
+    if i < len(s):
+        s = s[:i] + s[i].upper() + s[i+1:]
+    return s
+
+def smart_autopunct(user_text: str) -> str:
+    s = user_text.strip()
+    if len(s) > 20:
+        return capitalize_spanish(s)
+    norm = normalize_for_route(s)
+    if norm in SPECIAL_NOPUNCT:
+        s = re.sub(r'[¿?!¡]+', '', s).strip()
+        return capitalize_spanish(s)
+    if norm.startswith("y si "):
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+    if "?" in s and "¿" not in s:
+        s = "¿" + s
+        return capitalize_spanish(s)
+    if "!" in s and "¡" not in s:
+        s = "¡" + s
+        return capitalize_spanish(s)
+    if is_slang_greeting(norm):
+        s = f"¡{s}!"
+        return capitalize_spanish(s)
+    if needs_question_marks(norm):
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+    toks = norm.split()
+    if toks and toks[0] in _Q_VERB_STARTERS:
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+    if re.match(r"^(me\s+ayudas?|me\s+puedes|podrias?|podras?)\b", norm):
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+    if needs_exclam(norm):
+        s = f"¡{s}!"
+        return capitalize_spanish(s)
+    return capitalize_spanish(s)
+
+
+#-------------------------------------------------------------------------
+# Seeds & helpers
+#-------------------------------------------------------------------------
 
 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)
+    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
+# --- Personalidades (solo estilo en prompt; parámetros ya vienen del sidebar) ---
+
+def persona_style_prompt(persona: str, domain: str) -> str:
+    """Instrucción breve de estilo según personalidad y dominio (technical/social)."""
+    if persona == "Enthusiastic":
+        return (
+            "Responde de forma creativa, usa al menos 232 palabras. ")
+    if persona == "Normal":  # ya no se usa, pero por compatibilidad
+        return ""
+    return ""  # Assistant response
+
+#-------------------------------------------------------------------------
+# Classifier
+#-------------------------------------------------------------------------
+
+def classify_context(question, label_classes, model, tokenizer, device):
+    model = model.to(device)
+    inputs = tokenizer(question, return_tensors="pt", padding=True, truncation=True, max_length=128)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+    pred_intent = torch.argmax(logits, dim=1).item()
+    predicted_label = label_classes[pred_intent]
+    return predicted_label
+
+#-------------------------------------------------------------------------
+# Chatbot response for technical contexts using a Hugging Face model
+#-------------------------------------------------------------------------
 
-# =========================
-# 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
+    persona_name = (gen_params or {}).get("persona", st.session_state.get("persona", "Normal"))
+    style = persona_style_prompt(persona_name, "technical")
+    
+    # Promp Engineering para ayudar al asistente a encontrar la mejor respuesta
+    input_text = f"{style}Context: {context} [SEP] Question: {question}."
+        
+    st.session_state["last_prompt"] = input_text  # o prompt
     st.session_state["just_generated"] = True
-
-    enc = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
+    #st.rerun()
+    enc = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True, max_length=256).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))
+    # --- construir kwargs de generación, SIN tocar nada por personalidad ---
+    max_new   = int((gen_params).get("max_new_tokens"))
+    min_new   = int((gen_params).get("min_tokens"))          # <- ahora SIEMPRE min_new_tokens
+    no_repeat = int((gen_params).get("no_repeat_ngram_size"))
+    rep_pen   = float((gen_params).get("repetition_penalty"))
     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))
+        temperature = float((gen_params or {}).get("temperature", 0.7))
         top_p       = float((gen_params or {}).get("top_p", 0.9))
         kwargs = dict(
-            do_sample=True, num_beams=1,
+            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),
+            min_new_tokens=max(0, min_new),   # 👈 consistente
             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,
+            eos_token_id=tokenizer.eos_token_id,
+            pad_token_id=tokenizer.pad_token_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,
+            do_sample=False,
+            num_beams=num_beams,
+            length_penalty=length_penalty,
             max_new_tokens=max_new,
-            min_new_tokens=max(0, min_new),
+            min_new_tokens=max(0, min_new),   # 👈 también aquí (no min_length)
             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,
+            eos_token_id=tokenizer.eos_token_id,
+            pad_token_id=tokenizer.pad_token_id,
         )
 
     out_ids = model.generate(
@@ -317,239 +574,248 @@ def technical_asnwer(question, context, model, tokenizer, device, gen_params=Non
     )
     text = tokenizer.decode(out_ids[0], skip_special_tokens=True)
 
-    if persona_name == "Mori Normal":
+    if persona_name == "Normal":
         text = truncate_sentences(text, max_sentences=1)
 
     st.session_state["last_response"] = text
+    #st.rerun()
+
+    
     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"
-    )
+#-------------------------------------------------------------------------
+# Chatbot response for social contexts using a Hugging Face model
+#-------------------------------------------------------------------------
 
-    prompt = build_rag_prompt_technical(base_prompt, question, passages)
+def social_asnwer(question, model, tokenizer, device, gen_params=None, block_web=True):
+    
+    model = model.to(device).eval()
+    persona_name = (gen_params or {}).get("persona", st.session_state.get("persona", "Normal"))
+    prompt_type  = st.session_state.get("prompt_type", "Zero-shot")
+    prompt = question
 
-    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["last_prompt"] = prompt  # o 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)
+ 
+    enc = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=192).to(device)
 
-    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")
+    bad_words = ["[", "Thanks", "thank you"]
+    if block_web:
+        bad_words += ["website", "http", "www", ".com"]
+    bad_ids = [tokenizer(bw, add_special_tokens=False).input_ids for bw in bad_words]
 
-    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
+    
+    max_new = int((gen_params).get("max_new_tokens"))
+    min_tokens = int((gen_params).get("min_tokens"))
+    min_length = int(enc["input_ids"].shape[1]) + max(0, min_tokens)
+    no_repeat = int((gen_params).get("no_repeat_ngram_size"))
+    rep_pen = float((gen_params).get("repetition_penalty"))
+    mode = (gen_params or {}).get("mode", "beam")
 
     if mode == "sampling":
-        temperature = float((gen_params or {}).get("temperature", 0.8))
-        top_p       = float((gen_params or {}).get("top_p", 0.9))
+        temperature = float((gen_params or {}).get("temperature", 0.7))
+        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),
+            #min_length=min_length,
+            min_new_tokens=max(0, min_tokens),
             no_repeat_ngram_size=no_repeat,
             repetition_penalty=max(1.0, rep_pen),
-            eos_token_id=eos_id,
-            pad_token_id=pad_id,
+            bad_words_ids=bad_ids,
+            eos_token_id=tokenizer.eos_token_id,
+            pad_token_id=tokenizer.pad_token_id,           
         )
     else:
-        num_beams      = max(2, int((gen_params or {}).get("num_beams", 4)))
+        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),
+            #min_length=min_length,
+            min_new_tokens=max(0, min_tokens),   # <- usar min_new_tokens
             no_repeat_ngram_size=no_repeat,
             repetition_penalty=max(1.0, rep_pen),
-            eos_token_id=eos_id,
-            pad_token_id=pad_id,
+            bad_words_ids=bad_ids,
+            eos_token_id=tokenizer.eos_token_id,
+            pad_token_id=tokenizer.pad_token_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)
+    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 == "Normal":
+        text = truncate_sentences(text, max_sentences=2)
+    #text = anti_echo(text, question)
     text = polish_spanish(text)
+    text = capitalize_spanish(text)
 
     st.session_state["last_response"] = text
+    #st.rerun()
+
+    
     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)
+#-------------------------------------------------------------------------
+# Rule overrides
+#-------------------------------------------------------------------------
 
-    archivo_csv = stats_dir / "conversaciones_log.csv"
-    existe_csv = archivo_csv.exists()
+def rule_intent_override(user_text: str, predicted_label: str) -> str:
+    n = normalize_for_route(user_text)
+    if re.fullmatch(r"(motivame|motiva|animame|animo|ayudame|que tranza|qué tranza|que tranza)", n):
+        return "social"
+    return predicted_label
 
-    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])
+#-------------------------------------------------------------------------
+# Router
+#-------------------------------------------------------------------------
 
-    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")
+def contextual_asnwer(question, label_classes, context_model, cont_tok,
+                      tec_model, tec_tok, soc_model, soc_tok, device, gen_params=None, block_web=True):
+    context = classify_context(question, label_classes, context_model, cont_tok, device)
+    context = rule_intent_override(question, context)
 
-# =========================
-# 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
-    )
+    context_icons = {
+        "social": "💬", "modelos": "🔧", "evaluación": "📏", "optimización": "⚙️",
+        "visualización": "📈", "aprendizaje": "🧠", "vida digital": "🧑‍💻",
+        "estadística": "📊", "infraestructura": "🖥", "datos": "📂", "transformación digital": "🌀"}
+    icon = context_icons.get(context, "🧠")
 
-# =========================
+    if gen_params and "seed" in gen_params:
+        set_seeds(gen_params["seed"])
+
+    if context == "social":
+        return social_asnwer(question, soc_model, soc_tok, device, gen_params=gen_params, block_web=block_web), context
+    else:
+        return technical_asnwer(question, context, tec_model, tec_tok, device, gen_params=gen_params), context
+
+#***************************************************************************
 # MAIN
-# =========================
+#***************************************************************************
+
 if __name__ == '__main__':
-    # Estado persistente
+
+    # --- Estado que debe persistir en todos los reruns ---
     ss = st.session_state
     ss.setdefault("historial", [])
     ss.setdefault("last_prompt", "")
     ss.setdefault("last_response", "")
     ss.setdefault("just_generated", False)
+    
+    # Sidebar (control total)
+    GEN_PARAMS = sidebar_params()
+    GEN_PARAMS["persona"] = st.session_state.persona  # por si acaso
+
+    # Setting historial for the current user
+    #if "historial" not in st.session_state:
+    #    st.session_state.historial = []
+
+    # Assigning a new ID to the current user
+    if "user_id" not in st.session_state:
+        st.session_state["user_id"] = str(uuid.uuid4())[:8]
+
+    # Loading classifier encoder classes:
+    labels_path = hf_hub_download(repo_id="tecuhtli/assistant-classifier-bert", filename="context_labels.pkl", use_auth_token=HF_TOKEN)
+    label_classes = joblib.load(labels_path)
+
+    # Loading Saved Models  
+    # Modelo Contexto
+    context_model = AutoModelForSequenceClassification.from_pretrained("tecuhtli/assistant-classifier-bert", use_auth_token=HF_TOKEN)    
+    cont_tok = AutoTokenizer.from_pretrained("tecuhtli/assistant-classifier-bert", use_auth_token=HF_TOKEN)
+    
+    # Modelo Técnico
+    tec_tok = AutoTokenizer.from_pretrained("tecuhtli/assistant-technical-t5", use_auth_token=HF_TOKEN) 
+    tec_model = AutoModelForSeq2SeqLM.from_pretrained("tecuhtli/assistant-technical-t5", use_auth_token=HF_TOKEN) 
 
-    # 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,
-    }
+    # Modelo Social
+    soc_tok = AutoTokenizer.from_pretrained("tecuhtli/assistant-social-t5", use_auth_token=HF_TOKEN) 
+    soc_model = AutoModelForSeq2SeqLM.from_pretrained("tecuhtli/assistant-social-t5", use_auth_token=HF_TOKEN) 
 
-    # ID de sesión
-    if "user_id" not in ss:
-        ss["user_id"] = str(uuid.uuid4())[:8]
+    # Available Device
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-    # 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) 
+    # Defining Assistant Presentation
+    st.title("🤖 Your Personal Assistant 🎓")
 
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    st.caption("🙋🏽‍ You can ask me about technical concepts such as visualization, data cleaning, BI, and more.")
+    st.caption("🙇🏽 I can *only* understand and answer in Spanish (🦅🇲🇽🌵).")
+    st.caption("➡️ At this stage, I can respond to simple questions such as:")
+    st.caption("   • ¿Cómo estás?   • ¿Qué es...?   • Explícame algo   • Define algo   • ¿Para qué sirve...?")
+
+    st.caption("😊 If you want to know me better, visit: [hazutecuhtli.github.io](https://hazutecuhtli.github.io)")
 
-    # Presentación (solo técnico)
-    st.title("🤖 Mori - Tu Asistente Personal 🎓")
-    st.caption("🙋🏽‍ Puedes preguntarme conceptos técnicos como visualización, limpieza, BI, etc.")
-    st.caption("🙇🏽‍ Por el momento, solo puedo contestar preguntas simples como:")
-    st.caption("➡️ ¿Cómo estás? ¿Qué son?, Explícame algo, Define algo, ¿Para qué sirven?")
-    st.caption("🦾 Me siguen mejorando, más sobre mí en: [hazutecuhtli.github.io](https://github.com/hazutecuhtli/Mori_Development)")
     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"]
+    st.caption("✏️ Type **'salir'** to exit.")
+
+    # 🔁 Limpieza segura antes del formulario
+    if st.session_state.pop("_clear_entrada", False):
+        if "entrada" in st.session_state:
+            del st.session_state["entrada"]
 
-    # Respuesta flash de ciclo anterior
-    _flash = ss.pop("_flash_response", None)
+    # 🧠 Flash de respuesta (la guardamos, pero la mostraremos después del form)
+    _flash = st.session_state.pop("_flash_response", None)
 
-    # Formulario
-    with st.form("formulario_mori"):
+
+    with st.form("formulario_assistant"):
         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 😅")
+            st.info("Chatbot: ¿Podrías repetir eso? No entendí bien 😅")
         else:
-            response = answer_technical_only(user_question, device, GEN_PARAMS, tec_model, tec_tok)
+            response, context = contextual_asnwer(
+                user_question, label_classes, context_model, cont_tok,
+                tec_model, tec_tok, soc_model, soc_tok, device,
+                gen_params=GEN_PARAMS, block_web=True,
+            )
 
-            # Historial
+            # 🧠 Guarda historial
             hora_actual = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            ss.historial.append(("Tú", user_question, hora_actual))
+            st.session_state.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))
+            st.session_state.historial.append(("Assistant", response, hora_actual))
+
+            # 💾 Guarda conversación
+            saving_interaction(user_question, response, context, st.session_state["user_id"])
+
+            # 🟩 Guarda respuesta para mostrar después del rerun
+            st.session_state["_flash_response"] = response
 
-            # Guardado persistente
-            saving_interaction(user_question, response, "procesamiento de datos", ss["user_id"])
+            # 🧼 Limpieza del textarea en el próximo ciclo
+            st.session_state["_clear_entrada"] = True
 
-            # Flash y limpieza
-            ss["_flash_response"] = response
-            ss["_clear_entrada"] = True
+            # ♻️ Forzar refresh (sidebar verá el nuevo prompt)
             st.rerun()
 
-    # Mostrar respuesta flash
+    # -----------------------------------------------------------
+    # 💬 Mostrar la respuesta actual (flash) justo aquí ↓↓↓
+    # -----------------------------------------------------------
     if _flash:
         st.success(_flash)
 
-    # Historial + descarga
-    if ss.historial:
+    # Mostrar último mensaje (opcional, arriba de todo)
+    #if st.session_state.get("just_generated"):
+    #    if st.session_state["last_response"]:
+    #        st.success(st.session_state["last_response"])
+    #    st.session_state["just_generated"] = False
+
+    # ... formulario y lógica de respuesta ...
+
+    # 🔁 Historial con estilo chat y contenedor con scroll
+    if st.session_state.historial:
         st.markdown("---")
 
+        # 💾 Botón de descarga arriba del historial
         lineas = []
-        for msg in reversed(ss.historial):
+        for msg in reversed(st.session_state.historial):
             if len(msg) == 3:
                 autor, texto, hora = msg
                 lineas.append(f"[{hora}] {autor}: {texto}")
@@ -561,12 +827,12 @@ if __name__ == '__main__':
         st.download_button(
             label="💾 Descargar conversación como .txt",
             data=texto_chat,
-            file_name="conversacion_mori.txt",
+            file_name="conversacion_assistant.txt",
             mime="text/plain",
             use_container_width=True
         )
 
-        # Contenedor con estilo
+        # 🪟 Contenedor con scroll y burbujas
         st.markdown(
             """
             <div id="chat-container" style="
@@ -582,7 +848,7 @@ if __name__ == '__main__':
             unsafe_allow_html=True
         )
 
-        for msg in reversed(ss.historial):
+        for msg in reversed(st.session_state.historial):
             if len(msg) == 3:
                 autor, texto, _ = msg
             else:
@@ -632,6 +898,7 @@ if __name__ == '__main__':
                 )
 
         st.markdown("</div>", unsafe_allow_html=True)
+                
 #***************************************************************************
 # FIN
 #***************************************************************************