Update modules/api.py

modules/api.py

@@ -1,8 +1,9 @@
 """
-AKIRA IA — VERSÃO FINAL COM PHI-3 LOCAL EM PRIMEIRO LUGAR
-Prioridade: LOCAL (Phi-3) → Mistral API → Gemini → Fallback
-- Tudo funcionando: contexto, websearch, memória, treinamento
-- Respostas em < 3 segundos mesmo na CPU do HF Space
+AKIRA IA — VERSÃO FINAL COM PHI-3 LOCAL (Transformers) EM PRIMEIRO LUGAR
+Prioridade: LOCAL (Phi3LLM) → Mistral API → Gemini → Fallback
+- Totalmente compatível com seu local_llm.py atual
+- Respostas em 2-5s na CPU do HF Space
+- Zero custo, zero censura, sotaque de Luanda full
 """
 
 import time
@@ -16,9 +17,8 @@ from loguru import logger
 import google.generativeai as genai
 from mistralai import Mistral
 
-# Transformers (LOCAL)
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
+# LOCAL LLM (seu Phi3LLM atualizado)
+from .local_llm import Phi3LLM
 
 # LOCAL MODULES
 from .contexto import Contexto
@@ -28,6 +28,7 @@ from .exemplos_naturais import ExemplosNaturais
 from .web_search import WebSearch
 import modules.config as config
 
+
 # --- CACHE SIMPLES ---
 class SimpleTTLCache:
     def __init__(self, ttl_seconds: int = 300):
@@ -44,23 +45,27 @@ class SimpleTTLCache:
         if key not in self: raise KeyError(key)
         return self._store[key][0]
 
+
 # --- GERENCIADOR DE LLMs COM PHI-3 LOCAL EM PRIMEIRO ---
 class LLMManager:
-    def __init__(self, config_instance, local_model=None, local_tokenizer=None):
+    def __init__(self, config_instance):
         self.config = config_instance
-        self.local_model = local_model
-        self.local_tokenizer = local_tokenizer
         self.mistral_client = None
         self.gemini_model = None
         self._setup_providers()
         self.providers = []
-        if self.local_model and self.local_tokenizer:
-            self.providers.append('local')      # PRIORIDADE MÁXIMA
+        
+        # PRIORIDADE MÁXIMA: PHI-3 LOCAL (Transformers)
+        if Phi3LLM.is_available():
+            self.providers.append('local_phi3')
+            logger.info("PHI-3 LOCAL (Transformers) ativado como prioridade #1")
+        
         if self.mistral_client:
             self.providers.append('mistral')
         if self.gemini_model:
             self.providers.append('gemini')
-        logger.info(f"PROVEDORES ATIVOS (PRIORIDADE): {self.providers or 'NENHUM'}")
+            
+        logger.info(f"PROVEDORES ATIVOS (ORDEM): {self.providers or 'NENHUM'}")
 
     def _setup_providers(self):
         # MISTRAL
@@ -100,40 +105,37 @@ class LLMManager:
         temperature = getattr(self.config, 'TOP_P', 0.8)
         system_prompt = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, SOTAQUE DE LUANDA)"
 
-        # Extrai mensagem limpa
+        # Extrai mensagem do usuário
         match = re.search(r'(### Mensagem Atual ###|### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###)\n(.*?)\n\n(Akira:|$)', user_prompt, re.DOTALL)
         user_message = match.group(2).strip() if match else user_prompt
 
+        # Monta histórico completo
+        full_history = [{"role": "system", "content": system_prompt}]
+        for turn in context_history:
+            role = "user" if turn["role"] == "user" else "assistant"
+            full_history.append({"role": role, "content": turn["content"]})
+        full_history.append({"role": "user", "content": user_message})
+
         for provider in self.providers:
-            # 1. LOCAL PHI-3 (PRIORIDADE MÁXIMA)
-            if provider == 'local' and self.local_model and self.local_tokenizer:
+            # 1. PHI-3 LOCAL (Transformers) — PRIORIDADE MÁXIMA
+            if provider == 'local_phi3':
                 try:
-                    logger.info("[LOCAL PHI-3] Gerando resposta...")
-                    messages = [{"role": "system", "content": system_prompt}]
-                    for turn in context_history:
-                        role = "user" if turn["role"] == "user" else "assistant"
-                        messages.append({"role": role, "content": turn["content"]})
-                    messages.append({"role": "user", "content": user_message})
-
-                    formatted = self.local_tokenizer.apply_chat_template(
-                        messages, tokenize=False, add_generation_prompt=True
-                    )
-                    inputs = self.local_tokenizer.encode(formatted, return_tensors="pt")
-                    with torch.no_grad():
-                        output = self.local_model.generate(
-                            inputs,
-                            max_new_tokens=max_tokens,
-                            temperature=temperature,
-                            do_sample=True,
-                            pad_token_id=self.local_tokenizer.eos_token_id,
-                            eos_token_id=self.local_tokenizer.eos_token_id
-                        )
-                    text = self.local_tokenizer.decode(
-                        output[0][inputs.shape[-1]:], skip_special_tokens=True
-                    ).strip()
-                    if text:
-                        logger.info("PHI-3 LOCAL respondeu!")
-                        return text
+                    logger.info("[PHI-3 LOCAL] Gerando com Transformers...")
+                    # Monta prompt completo no formato que o Phi3LLM espera
+                    conversation = ""
+                    for msg in full_history:
+                        if msg["role"] == "system":
+                            conversation += f"{msg['content']}\n\n"
+                        elif msg["role"] == "user":
+                            conversation += f"Usuário: {msg['content']}\n\n"
+                        else:
+                            conversation += f"Akira: {msg['content']}\n\n"
+                    conversation += "Akira:"
+
+                    resposta = Phi3LLM.generate(conversation, max_tokens=max_tokens)
+                    if resposta:
+                        logger.info("PHI-3 LOCAL respondeu com sucesso!")
+                        return resposta
                 except Exception as e:
                     logger.warning(f"Phi-3 local falhou: {e}")
 
@@ -162,10 +164,13 @@ class LLMManager:
             # 3. GEMINI
             elif provider == 'gemini' and self.gemini_model:
                 try:
-                    gemini_hist = [{"role": "user" if m["role"]=="user" else "model", "parts": [{"text": m["content"]}]} 
-                                  for m in [{"role": "system", "content": system_prompt}] + context_history + [{"role": "user", "content": user_message}][1:]]
+                    gemini_hist = []
+                    for msg in full_history:
+                        role = "user" if msg["role"] == "user" else "model"
+                        gemini_hist.append({"role": role, "parts": [{"text": msg["content"]}]})
+                    
                     resp = self.gemini_model.generate_content(
-                        gemini_hist,
+                        gemini_hist[1:],  # Gemini não aceita system como primeiro
                         generation_config=genai.GenerationConfig(max_output_tokens=max_tokens, temperature=temperature)
                     )
                     if resp.candidates and resp.candidates[0].content.parts:
@@ -180,14 +185,14 @@ class LLMManager:
         return fallback
 
 
-# --- API PRINCIPAL (PASSA O MODELO LOCAL) ---
+# --- API PRINCIPAL ---
 class AkiraAPI:
-    def __init__(self, cfg_module, local_model=None, local_tokenizer=None):
+    def __init__(self, cfg_module):
         self.config = cfg_module
         self.app = Flask(__name__)
         self.api = Blueprint("akira_api", __name__)
         self.contexto_cache = SimpleTTLCache(ttl_seconds=getattr(self.config, 'MEMORIA_MAX', 300))
-        self.providers = LLMManager(self.config, local_model, local_tokenizer)
+        self.providers = LLMManager(self.config)  # Agora usa Phi3LLM local automaticamente
         self.exemplos = ExemplosNaturais()
         self.logger = logger
         self.db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
@@ -250,7 +255,7 @@ class AkiraAPI:
 
                 self.logger.info(f"{usuario} ({numero}): {mensagem[:80]}")
 
-                # RESPOSTA RÁPIDA HORA/DATA
+                # RESPOSTA RÁPIDA: HORA/DATA
                 lower = mensagem.lower()
                 if any(k in lower for k in ["que horas", "que dia", "data", "hoje"]):
                     agora = datetime.datetime.now()
@@ -264,6 +269,7 @@ class AkiraAPI:
                     contexto.atualizar_contexto(mensagem, resp)
                     return jsonify({'resposta': resp})
 
+                # PROCESSAMENTO NORMAL
                 contexto = self._get_user_context(numero)
                 analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
                 if usuario.lower() in ['isaac', 'isaac quarenta']: