Update app.py

app.py

@@ -95,177 +95,660 @@ def load_model(path_str):
     return model, tokenizer
 
 
-# Funcion para clasificar las preguntas del usuario definiendo el contexto de las mismas
-def classify_context(question, label_classes, model, tokenizer, device):
+#-------------------------------------------------------------------------
+#Function to correct Spanish sentences' punctuation and missing characters
+#-------------------------------------------------------------------------
+
+def polish_spanish(s: str) -> str:
+
+    """Correcting Spanish sentences
+
+    Args:
+        s (str): Input Spanish sentence.
+
+    Returns:
+        str: A corrected and polished version of the input.
+    """
+
+    # Normalizing input for correct standardization
+    s = unicodedata.normalize("NFC", s).strip()
+
+    # Removing Model names if leaked into generated inputs prompts
+    s = re.sub(r'\s*[\[\(]\s*Mori\s+(?:Social|T[eé]nico|T[eé]cnico)\s*[\]\)]\s*', '', s, flags=re.I)
+
+    # Correcting missing or misspelled words
+    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)\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'),
+        (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)
 
-    '''
-    inputs:
+    # Abrir exclamación para "Eso es todo!" (si viene sin ¡ al inicio)
+    s = re.sub(r'(?i)^eso es todo!(?P<r>(\s|$).*)', r'¡Eso es todo!\g<r>', s)
+    
+    # Adds the ¿ character in in case they are missed
+    def add_opening_q(m):
+        cuerpo = m.group('qbody')
+        # evita duplicar si ya trae '¿'
+        if '¿' in cuerpo:
+            return m.group(0)
+        return f"{m.group('pre')}¿{cuerpo}"
     
-    question --> Pregunta formulada por el usuario
-    label_classes --> Clases del label encoder para decodificar inferencias
-    model --> Clasificador para determinar el contexto de las pregutnas
-    tokenizer --> Tokenizer usada para clasificar contextos    
-    device --> Usar el GPU o el CPU dependiendo de su disponibilidad    
+    s = re.sub(r'(?P<pre>(^|[\.!\…]\s+))(?P<qbody>[^?]*\?)', add_opening_q, s)
 
-    outsputs:
+    # Adds the ¡ character in in case they are missed
+    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)
 
-    predicted_label --> Clasificacion de la pregunta en diversos contextos (clases)
+    # Final cleaning
+    s = re.sub(r'\s+', ' ', s).strip()
+    if s and s[-1] not in ".!?…":
+        s += "."
+        
+    return s
 
-    '''
+#-------------------------------------------------------------------------
+# Function to remove repeated input in the Model answer
+#-------------------------------------------------------------------------
 
-    # Moviendo el modelo al device disponible
-    model = model.to(device)
-    
-    # Procesando la entrada del usuario
-    inputs = tokenizer(question, return_tensors="pt", padding=True, truncation=True, max_length=128)
-    inputs = {key: val.to(device) for key, val in inputs.items()}
+
+def anti_echo(response: str, user_text: str) -> str:
     
-    # Clasificacion de la pregunta del usuario en contextos
-    with torch.no_grad():
-        outputs = model(**inputs)
-        logits = outputs.logits
+    """Removing duplicating words
+
+    Args:
+        response (str): Model response
+        user_text (str): Input Spanish sentence.
+
+    Returns:
+        str: Model response without duplicated input sentence words
+    """
+
+    # Normalizing sentences
+    rn = normalize_for_route(response)
+    un = normalize_for_route(user_text)
+
+    # Removing initial unexpected extra characters
+    def _clean_leading(s: str) -> str:
+        s = re.sub(r'^\s*[,;:\-–—]\s*', '', s)
+        s = re.sub(r'^\s+', '', s)
+        return s
+
+    # Removing user input text repeated within model response
+    if len(un) >= 4 and rn.startswith(un):
+        # Removing the first sentence, before the defined separator
+        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
+
+
+#-------------------------------------------------------------------------
+# Function to remove unwanted characters, normalizacion of sentences
+#-------------------------------------------------------------------------
+
+def normalize_for_route(s: str) -> str:
+
+    """Function to standardize sentences
+
+    Args:
+        s (str): Sentence
+
+    Returns:
+        str: Corrected or Standardized Sentence
+    """
+
+    # Standardizing
+    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()
     
-    # Inferencia del clasificador
-    pred_intent = torch.argmax(logits, dim=1).item()
-    predicted_label = label_classes[pred_intent]
+    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"}
+
+# 3) verbos 2ª persona al inicio -> pregunta corta
+_Q_VERB_STARTERS = {"eres","estas","estás","puedes","sabes","tienes","quieres","conoces",
+        "crees","piensas","dirias","dirías","podrias","podrías","podras","podrás"}
+
+#-------------------------------------------------------------------------
+# Function to determine if a ¿ character needs to be added
+#-------------------------------------------------------------------------
+
+def needs_question_marks(norm: str) -> bool:
+
+    """Function to standardize sentences
+
+    Args:
+        norm (str): User text input
+
+    Returns:
+        bol: If the character is missing or not
+    """
     
-    return predicted_label
+    if "?" in norm: return False
+    for w in _Q_STARTERS:
+        if norm.startswith(w + " ") or norm == w:
+            return True
+    return False
 
 
+#-------------------------------------------------------------------------
+#  Function to determine if a ¡ character needs to be added
+#-------------------------------------------------------------------------
 
-# Funcion para generar respuestas tecnicas de Mori
-def technical_asnwer(question, context, model, tokenizer, device):
 
-    '''
-    inputs:
+def needs_exclam(norm: str) -> bool:
+
+    """Function to standardize sentences
+
+    Args:
+        norm (str): User text input
+
+    Returns:
+        bol: If the character is missing or not
+    """
     
-    question --> Pregunta formulada por el usuario
-    context --> Contexto de la preguntadel usario definido por el clasificador
-    model --> Modelo de Mori para responder preguntas tecnicas
-    tokenizer --> Tokenizer usado para procesar entradas y decoodificar respuestas
-    device --> Usar el GPU o el CPU dependiendo de su disponibilidad
+    if "!" in norm: return False
 
-    outsputs:
+    return any(t in norm for t in _EXC_TRIGGERS)
 
-    response --> Respues de Mori tecnico (Modelo tecnico)
 
-    '''
+#-------------------------------------------------------------------------
+# Function that detects greetings in slang form
+#-------------------------------------------------------------------------
+
+
+def is_slang_greeting(norm: str) -> bool:
+
+
+    """Recognizing slang greetings
+
+    Args:
+        norm (str): User text input
+
+    Returns:
+        bol: If the character is missing or not
+    """
     
-    # Moviendo el modelo al device disponible
-    model = model.to(device)    
+    # Defining slang greetings
+    SHORT = {
+        "que pex", "que onda", "ke pex", "k pex", "q onda",
+        "kiubo", "quiubo", "quiubole", "quiubole", "kionda", "q onda", "k onda",
+        "que rollo", "ke onda", "que show", "que tranza"}
+
+    # Finding greetings within the input
+    if norm in SHORT:
+        return True
+
+    # Looking for more specific forms
+    if re.match(r"^(q|k|ke|que)\s+(pex|onda|rollo|show|tranza)\b", norm):
+        return True
+
+    # Looking for more specific forms
+    if re.match(r"^(kiubo|quiubo|quiubole|quiúbole|quiubol[e]?)\b", norm):
+        return True
+
+    return False
+
+#-------------------------------------------------------------------------
+# Function to capitalize the model response
+#-------------------------------------------------------------------------
+
     
-    # Promp Engineering para ayudar a Mori a encontrar la mejor respuesta
-    input_text = f"Context: {context} [SEP] Question: {question}"
+def capitalize_spanish(s: str) -> str:
+
+
+    """Recognizing slang greetings
+
+    Args:
+        s (str): User text input
+
+    Returns:
+        str: Capitalized user text input
+    """
     
-    # Tokenizando el texto de entrada
-    inputs = tokenizer(input_text, return_tensors="pt").to(device)
+    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
+
+
+#-------------------------------------------------------------------------
+# Function to correct Spanish sentences grammar and punctuation
+#-------------------------------------------------------------------------
+
+
+def smart_autopunct(user_text: str) -> str:
+
+
+    """Correcting grammar and punctuation
+
+    Args:
+        user_text (str): User text input
+
+    Returns:
+        str: Corrected user text input
+    """
+
+    # 
+    s = user_text.strip()
+    if len(s) > 20:
+        return capitalize_spanish(s)
+
+    #
+    norm = normalize_for_route(s)
+
+    # Removing unexpected signs from specific slang
+    if norm in SPECIAL_NOPUNCT:
+        # elimina cualquier signo si el usuario los puso y capitaliza
+        s = re.sub(r'[¿?!¡]+', '', s).strip()
+        return capitalize_spanish(s)
+
+    # Adding question marks to specific user input text, in case they are missed
+    if norm.startswith("y si "):
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+
+    # Completing missing question marks or exclamation marks
+    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)
     
-    # Generando la respuesta
-    summary_ids = model.generate(inputs['input_ids'], max_length=150, num_beams=5, early_stopping=True)
+    # Adding exclamation marks to slang greetings
+    if is_slang_greeting(norm): 
+        s = f"¡{s}!"
+        return capitalize_spanish(s)
+
+    # Adding question marks to expected expressions
+    if needs_question_marks(norm):  
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+
+    # Adding question marks to sentences with an expected form
+    toks = norm.split()
+    if toks and toks[0] in _Q_VERB_STARTERS:
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+
+    # Adding question marks to specific expressions
+    if re.match(r"^(me\s+ayudas?|me\s+puedes|podrias?|podras?)\b", norm):
+        s = f"¿{s}?"
+        return capitalize_spanish(s)
+
+    # Adding exclamation marks to specific expressions
+    if needs_exclam(norm):         
+        s = f"¡{s}!"
+        return capitalize_spanish(s)
+
+    # Capitalizing the output
+    return capitalize_spanish(s)
+
+
+#-------------------------------------------------------------------------
+# Generating a social prompt from user input - RAG can be implemented here
+#-------------------------------------------------------------------------
+
+
+def build_prompt_social(user_text: str) -> str:
+
+    """Generating a social prompt from user input
+
+    Args:
+        user_text (str): User text input
+
+    Returns:
+        str: Generated prompt
+    """
     
-    # Decodificando la respuesta
-    response = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+    # Generating prompt
+    fixed = smart_autopunct(user_text)
+
+    return f"respuesta social: {fixed}"
+
+
+#-------------------------------------------------------------------------
+# Function to set the random seed for reproducibility of results
+#-------------------------------------------------------------------------
     
-    return "🧠 [Mori Técnico] " + response.strip()
 
+def set_seeds(seed: int = 42):
 
-# Funcion para generar respuestas sociales de Mori
-def social_asnwer(question, model, tokenizer, device):
+    """Function to set the random seed for reproducibility of results
 
-    '''
-    inputs:
+    Args:
+        seed (int): Random seed
+    """
     
-    question --> Pregunta formulada por el usuario
-    model --> Modelo de Mori para responder preguntas sociales
-    tokenizer --> Tokenizer usado para procesar entradas y decoodificar respuestas    
-    device --> Usar el GPU o el CPU dependiendo de su disponibilidad    
+    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
 
-    outsputs:
+#-------------------------------------------------------------------------
+# Function that classify the user input context, social or technical
+#-------------------------------------------------------------------------
 
-    response --> Respues de Mori social (Modelo social)
+def classify_context(question, label_classes, model, tokenizer, device):
+    
+    """
+    Classify the context of a user input text using a Hugging Face model.
 
-    '''
+    Args:
+        question (str): User input text, which will be classified as a specific context
+        label_classes (List[str]): List of all possible classes used be classify the user input
+        model (transformers.PreTrainedModel): Huggingface pretrained model, with fine-tuning
+        tokenizer (transformers.PreTrainedTokenizer):  Tokenizer, corresponding to the input model
+        device (torch.device): The device where the model will be running, torch.device("cuda") or torch.device("cpu"))
 
-    # Moviendo el modelo al device disponible
+    Returns:
+        str: Context related to the user input text
+    """
+
+    # Running the model on the selected device
     model = model.to(device)
 
-    # Tokenizando la entrada del usuario sin agregar <eos> explícitamente    
-    inputs = tokenizer(
-        question,  # ✅ sin agregar eos_token
-        return_tensors="pt",
-        padding=True,
-        truncation=True,
-        max_length=128  # ✅ especificado para evitar warning
-    ).to(device)
-
-    # Generando respuesta usando muestreo
-    output_ids = model.generate(
-        input_ids=inputs["input_ids"],
-        attention_mask=inputs["attention_mask"],  # ✅ FIX agregado
-        max_length=50,
-        pad_token_id= tokenizer.eos_token_id,
-        do_sample=True,
-        top_p=0.95,
-        top_k=50)
-
-    # Decodificando y limpiando la respuesta
-    response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+    # Generating tokens from user input
+    inputs = tokenizer(question, return_tensors="pt", padding=True, truncation=True, max_length=128)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    # Making inference about the use input context
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+
+    # Determining the user input context    
+    pred_intent = torch.argmax(logits, dim=1).item()
+    predicted_label = label_classes[pred_intent]
     
-    return "🤝 [Mori Social] " + response.strip()
+    return predicted_label
 
 
-# Funcion para generar respuesta general de Mori
-def contextual_asnwer(question, label_classes, context_model, cont_tok, tec_model, tec_tok, soc_model, soc_tok, device):
+#-------------------------------------------------------------------------
+# Chatbot response for technical contexts using a Hugging Face model
+#-------------------------------------------------------------------------
 
-    '''
-    inputs:
+def technical_asnwer(question, context, model, tokenizer, device):
     
-    question --> Pregunta formulada por el usuario
-    label_classes --> Clases del label encoder para decodificar inferencias
-    context_model --> Clasificador para determinar el contexto de las pregutnas
-    cont_tok --> Tokenizer usada para clasificar contextos
-    tec_model --> Modelo de Mori para responder preguntas tecnicas
-    tec_tok -->  Tokenizer usado por Mori Tenico
-    soc_model --> Modelo de Mori para responder preguntas sociales
-    soc_tok --> Tokenizer usado por Mori Social
-    device --> Usar el GPU o el CPU dependiendo de su disponibilidad    
+    """
+    Generate a chatbot response for technical contexts using a Hugging Face model.
 
-    outsputs:
+    Args:
+        question (str):  User input text
+        context (str): Technical context
+        model (transformers.PreTrainedModel): Huggingface pretrained model, with fine-tuning
+        tokenizer (transformers.PreTrainedTokenizer): Tokenizer, corresponding to the input model
+        device (torch.device): The device where the model will be running, torch.device("cuda") or torch.device("cpu"))
 
-    response --> Respues de Mori General (Respues con Prompt Engineering)
+    Returns:
+        str: The model's generated answer within the technical context
+    """
 
-    '''
+    # Running the model on the selected device    
+    model = model.to(device)
+    # Setting the model on eval mode
+    model.eval()
+
+    # Generating the promtp input to the technical model
+    #input_text = f"Context: {context} [SEP] Question: {question}"
+    input_text = f"definir: responde con la definición canónica exacta. Contexto={context} ; Pregunta={question}"
+    # Tokenizing the technical user input
+    enc = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True, max_length=256).to(device)
+
+    # Avoiding responses containing the following characters
+    bad_words = ["["]
+    bad_ids = [tokenizer(bw, add_special_tokens=False).input_ids for bw in bad_words]
+
+    # Generating responses from the technical model
+    out_ids = model.generate(
+        input_ids=enc["input_ids"],
+        attention_mask=enc["attention_mask"],
+        num_beams=4, do_sample=False,
+        max_new_tokens=160, min_new_tokens=24,
+        no_repeat_ngram_size=3,
+        bad_words_ids=bad_ids,
+        eos_token_id=tokenizer.eos_token_id,
+        pad_token_id=tokenizer.pad_token_id
+    )
+
+    # Translating model model-generated answer to a readable text
+    text = tokenizer.decode(out_ids[0], skip_special_tokens=True)
+
+    return polish_spanish(text)
+
+
+#-------------------------------------------------------------------------
+# Chatbot response for social contexts using a Hugging Face model
+#-------------------------------------------------------------------------
     
-    # Detectar contexto usando el clasificador
+
+def social_asnwer(question, model, tokenizer, device):
+
+    """
+    Generate a chatbot response for social contexts using a Hugging Face model.
+
+    Args:
+        question (str): User input text
+        model (transformers.PreTrainedModel): Huggingface pretrained model, with fine-tuning
+        tokenizer (transformers.PreTrainedTokenizer): Tokenizer, corresponding to the input model
+        device (torch.device): The device where the model will be running, torch.device("cuda") or torch.device("cpu"))
+
+    Returns:
+        str: The model's generated answer within the social context
+    """
+
+    # Running the model on the selected device   
+    model = model.to(device)
+    # Setting the model on eval mode    
+    model.eval()
+
+    # Generating the promtp input to the technical model
+    prompt = build_prompt_social(question)
+    enc = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=192).to(device)
+
+    # Avoiding responses containing the following characters
+    bad_words = ["[", "Thanks", "thank you", "website", "http", "www", ".com"]
+    bad_ids = [tokenizer(bw, add_special_tokens=False).input_ids for bw in bad_words]
+
+    # Generating responses from the social model 
+    out_ids = model.generate(
+        input_ids=enc["input_ids"],
+        attention_mask=enc["attention_mask"],
+        num_beams=4, do_sample=False,          # determinista
+        max_new_tokens=64, min_new_tokens=16,  # evita respuestas tipo “¡Descansa!”
+        no_repeat_ngram_size=3,
+        bad_words_ids=bad_ids,
+        eos_token_id=tokenizer.eos_token_id,
+        pad_token_id=tokenizer.pad_token_id
+    )
+
+    # Translating model model-generated answer to a readable text    
+    text = tokenizer.decode(out_ids[0], skip_special_tokens=True)
+
+    # Anti-echo code,  avoids input words within the model answer
+    text = anti_echo(text, question)
+
+    # Improving Spanish responses, grammatically and with respect special characters
+    text = polish_spanish(text)
+
+    # Capatilazing the model response
+    text = capitalize_spanish(text)
+
+    return text
+
+
+#-------------------------------------------------------------------------
+# Function to override the contextual classifier if the user input is short
+#-------------------------------------------------------------------------
+    
+
+def rule_intent_override(user_text: str, predicted_label: str) -> str:
+
+
+    """
+    Function to override the contextual classifier
+
+    Args:
+        user_text (str): User input text
+        predicted_label (str): Huggingface pretrained model, with fine-tuning
+
+    Returns:
+        str: Overridden context for the user input text
+    """
+
+    # Standardizing the user input
+    n = normalize_for_route(user_text)
+
+    # Overriding the classified context, in case the input is too short
+    if re.fullmatch(r"(motivame|motiva|animame|animo|ayudame|que tranza|qué tranza|que tranza mori|qué tranza mori)", n):
+        return "social"
+    return predicted_label
+
+
+#-------------------------------------------------------------------------
+# Function to determine the context of the user input, technical or social
+#-------------------------------------------------------------------------
+
+def contextual_asnwer(question, label_classes, context_model, cont_tok,
+                      tec_model, tec_tok, soc_model, soc_tok, device):
+
+
+    """
+    Function to override the contextual classifier
+
+    Args:
+        question (str): User input text, which will be classified as a specific context
+        label_classes (List[str]): List of all possible classes used be classify the user input
+        context_model (transformers.PreTrainedModel): Model, with fine-tuning, for classifying the input user into social or technical contexts
+        cont_tok (transformers.PreTrainedTokenizer):  Tokenizer, corresponding to the context classifier model
+        tec_model (transformers.PreTrainedModel): Model, with fine-tuning, for generating technical responses
+        tec_tok (transformers.PreTrainedTokenizer):  Tokenizer, corresponding to the technical model
+        soc_model (transformers.PreTrainedModel): Model, with fine-tuning, for generating social responses
+        soc_tok (transformers.PreTrainedTokenizer):  Tokenizer, corresponding to the social model        
+        device (torch.device): The device where the model will be running, torch.device("cuda") or torch.device("cpu"))
+
+    Returns:
+        str: Context related to the user input text
+    """
+
+    # Classifying user input text into a social or technical context
     context = classify_context(question, label_classes, context_model, cont_tok, device)
+    context = rule_intent_override(question, context)
 
-    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, "🧠")
-    #print(f"{icon} Contexto detectado: {context}") # (opcional para debug)
-    st.markdown(f"**{icon} Contexto detectado:** `{context}`")
+    # Characters used to improve the interface experience with the user
+    context_icons = {
+        "social": "💬", "modelos": "🔧", "evaluación": "📏", "optimización": "⚙️",
+        "visualización": "📈", "aprendizaje": "🧠", "vida digital": "🧑‍💻",
+        "estadística": "📊", "infraestructura": "🖥", "datos": "📂", "transformación digital": "🌀"}
 
-    if context == 'social':
-        
-        # Generar respuesta contextual usando el modelo social
-        response = social_asnwer(question, soc_model,soc_tok, device)
+    # Showing the context related to the user input text
+    icon = context_icons.get(context, "🧠")
+    print(f"{icon} Contexto detectado: {context}")
 
-    else:      
+    #return technical_asnwer(question, context, tec_model, tec_tok, device)
 
-        # Generar respuesta contextual usando el modelo tecnico
-        response = technical_asnwer(question, context, tec_model, tec_tok, device)
+    # Generating the Chatbot answer based on the trained models
+    if context == "social":
+        return social_asnwer(question, soc_model, soc_tok, device), context
+    else:
+        return technical_asnwer(question, context, tec_model, tec_tok, device), context
     
-    return response, context