Update modules/local_llm.py

modules/local_llm.py

@@ -1,18 +1,20 @@
-# modules/local_llm.py — VERSÃO FINAL OFICIAL: RAM FULL, CPU CHILL, LUANDA NO COMANDO!
 from llama_cpp import Llama
 import os
 from loguru import logger
 import threading
 
 # CAMINHOS NO HF SPACES (CORRIGIDOS PARA O AMBIENTE ATUAL)
-FINETUNED_PATH = "/home/user/data/finetuned_hermes"         # LoRA angolano
+FINETUNED_PATH = "/home/user/data/finetuned_phi3"        # LoRA angolano
 # CORREÇÃO: O Dockerfile baixa para /home/user/models/
-GGUF_PATH = "/home/user/models/openhermes-2.5-mistral-7b.Q4_K_M.gguf" 
+GGUF_FILENAME = "Phi-3-mini-4k-instruct.Q4_K_M.gguf"
+GGUF_PATH = f"/home/user/models/{GGUF_FILENAME}"
 
-class HermesLLM:
+class Phi3LLM:
     _llm = None
     _available_checked = False
     _is_available = False
+    MODEL_ID = "PHI-3 3.8B"
+    MODEL_SIZE_RAM_GB = "~7-8GB"
 
     @classmethod
     def is_available(cls) -> bool:
@@ -24,9 +26,9 @@ class HermesLLM:
             cls._is_available = os.path.isfile(GGUF_PATH)
             cls._available_checked = True
             if cls._is_available:
-                logger.info(f"HERMES 7B GGUF ENCONTRADO → {GGUF_PATH}")
+                logger.info(f"{cls.MODEL_ID} GGUF ENCONTRADO → {GGUF_PATH}")
             else:
-                logger.warning(f"HERMES 7B GGUF NÃO ENCONTRADO! Caminho: {GGUF_PATH}")
+                logger.warning(f"{cls.MODEL_ID} GGUF NÃO ENCONTRADO! Caminho: {GGUF_PATH}")
                 logger.warning("AKIRA VAI USAR MISTRAL/GEMINI COMO FALLBACK")
         return cls._is_available
 
@@ -34,28 +36,27 @@ class HermesLLM:
     def _get_llm(cls):
         """
         CARREGA O MODELO UMA ÚNICA VEZ → SINGLETON + mlock
-        RAM ATÉ O PESCOÇO → CPU SÓ 2 THREADS → 8-12s POR RESPOSTA
+        PHI-3 é menor (3.8B) → Deve usar menos RAM e ser mais rápido.
         """
         if cls._llm is None and cls.is_available():
             try:
-                logger.info("CARREGANDO OPENHERMES 7B GGUF Q4_K_M → RAM MÁXIMA, CPU MÍNIMA!")
+                logger.info(f"CARREGANDO {cls.MODEL_ID} GGUF Q4_K_M → RAM: {cls.MODEL_SIZE_RAM_GB}, CPU MÍNIMA!")
                 cls._llm = Llama(
                     model_path=GGUF_PATH,
-                    n_ctx=4096,         # Contexto gigante (mais RAM)
+                    n_ctx=4096,         # Contexto gigante
                     n_batch=512,        # Batch grande = menos CPU
                     n_threads=2,        # Só 2 threads → CPU em paz!
-                    n_gpu_layers=0,     # Tudo na RAM (HF Spaces free não tem GPU)
+                    n_gpu_layers=0,     # Tudo na RAM
                     use_mlock=True,     # Trava na RAM física → nunca swap!
                     verbose=False,
-                    n_parts=1,          # Carrega tudo de uma vez → RAM FULL
+                    n_parts=1,          # Carrega tudo de uma vez
                     seed=-1,
                     logits_all=True,
                 )
-                logger.success("HERMES 7B GGUF CARREGADO COM SUCESSO → ~14-16GB RAM USADA!")
+                logger.success(f"{cls.MODEL_ID} GGUF CARREGADO COM SUCESSO → {cls.MODEL_SIZE_RAM_GB} RAM USADA!")
 
                 # =================================================================
-                # CORREÇÃO: A linha abaixo estava a causar o 'AttributeError'.
-                # A funcionalidade LoRA foi removida para garantir que o modelo base funcione.
+                # TENTA CARREGAR LORA SE EXISTIR (funcionalidade depende da versão llama-cpp-python)
                 # =================================================================
                 lora_path = os.path.join(FINETUNED_PATH, "lora_leve")
                 if os.path.isdir(lora_path):
@@ -64,36 +65,44 @@ class HermesLLM:
                      logger.info("Usando modelo GGUF base (sem LoRA).")
 
             except Exception as e:
-                logger.error(f"ERRO CRÍTICO AO CARREGAR HERMES GGUF: {e}")
+                logger.error(f"ERRO CRÍTICO AO CARREGAR {cls.MODEL_ID} GGUF: {e}")
                 import traceback
                 logger.error(traceback.format_exc())
-                cls._llm = None  # Garante que não tente de novo
+                cls._llm = None # Garante que não tente de novo
         return cls._llm
 
     @classmethod
     def generate(cls, prompt: str, max_tokens: int = 60) -> str:
         """
-        GERA RESPOSTA COM HERMES LOCAL
-        max_tokens=60 → ~8-12 segundos no CPU free do HF Spaces
+        GERA RESPOSTA COM PHI-3 LOCAL
+        max_tokens=60 → Deve ser mais rápido que o Hermes (7B)
         """
         llm = cls._get_llm()
         if llm is None:
-            raise RuntimeError("HermesLLM não está disponível ou falhou ao carregar")
+            raise RuntimeError(f"{cls.MODEL_ID} não está disponível ou falhou ao carregar")
 
         try:
-            logger.info(f"[HERMES LOCAL] Gerando resposta → {max_tokens} tokens")
+            # FORMATO DE CHAT PHI-3: <|user|>PROMPT<|end|><|assistant|>
+            formatted_prompt = f"<|user|>\n{prompt}<|end|>\n<|assistant|>"
+
+            logger.info(f"[{cls.MODEL_ID} LOCAL] Gerando resposta → {max_tokens} tokens")
             output = llm(
-                prompt,
+                formatted_prompt,
                 max_tokens=max_tokens,
                 temperature=0.72,
                 top_p=0.92,
-                stop=["<|im_end|>", "\n\n", "User:", "Assistant:"],
+                stop=["<|end|>", "<|assistant|>", "<|user|>", "\n\n"],
                 echo=False,
             )
             text = output["choices"][0]["text"].strip()
-            logger.success(f"HERMES RESPONDEU EM ~10s → {len(text)} chars")
+            
+            # Limpeza adicional para garantir que não haja tags residuais
+            if text.startswith("<|assistant|>"):
+                text = text[len("<|assistant|>"):].lstrip()
+            
+            logger.success(f"{cls.MODEL_ID} RESPONDEU → {len(text)} chars")
             return text
 
         except Exception as e:
-            logger.error(f"ERRO NA GERAÇÃO COM HERMES: {e}")
+            logger.error(f"ERRO NA GERAÇÃO COM {cls.MODEL_ID}: {e}")
             raise