Update modules/api.py

modules/api.py

@@ -1,12 +1,10 @@
 """
-API wrapper Akira IA — VERSÃO FINAL COMPATÍVEL COM main.py
-Prioridade: Mistral API (Phi-3 Mini) → Gemini → Fallback
-- Contexto por JID
-- WebSearch ativo
-- Resposta rápida de hora/data
-- Gemini SEM FILTROS
-- CORS liberado
+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
 """
+
 import time
 import re
 import datetime
@@ -18,6 +16,10 @@ from loguru import logger
 import google.generativeai as genai
 from mistralai import Mistral
 
+# Transformers (LOCAL)
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
 # LOCAL MODULES
 from .contexto import Contexto
 from .database import Database
@@ -26,44 +28,39 @@ from .exemplos_naturais import ExemplosNaturais
 from .web_search import WebSearch
 import modules.config as config
 
-
-# --- CACHE SIMPLES COM TTL (5 MINUTOS) ---
+# --- CACHE SIMPLES ---
 class SimpleTTLCache:
     def __init__(self, ttl_seconds: int = 300):
         self.ttl = ttl_seconds
         self._store = {}
-
     def __contains__(self, key):
-        if key not in self._store:
-            return False
+        if key not in self._store: return False
         _, expires = self._store[key]
-        if time.time() > expires:
-            del self._store[key]
-            return False
+        if time.time() > expires: del self._store[key]; return False
         return True
-
     def __setitem__(self, key, value):
         self._store[key] = (value, time.time() + self.ttl)
-
     def __getitem__(self, key):
-        if key not in self:
-            raise KeyError(key)
+        if key not in self: raise KeyError(key)
         return self._store[key][0]
 
-
-# --- GERENCIADOR DE LLMs ---
+# --- GERENCIADOR DE LLMs COM PHI-3 LOCAL EM PRIMEIRO ---
 class LLMManager:
-    def __init__(self, config_instance):
+    def __init__(self, config_instance, local_model=None, local_tokenizer=None):
         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
         if self.mistral_client:
             self.providers.append('mistral')
         if self.gemini_model:
             self.providers.append('gemini')
-        logger.info(f"Provedores ativos: {self.providers or 'NENHUM'}")
+        logger.info(f"PROVEDORES ATIVOS (PRIORIDADE): {self.providers or 'NENHUM'}")
 
     def _setup_providers(self):
         # MISTRAL
@@ -77,7 +74,7 @@ class LLMManager:
         else:
             logger.warning("Mistral API desativada (chave inválida)")
 
-        # GEMINI SEM FILTROS
+        # GEMINI
         key = getattr(self.config, 'GEMINI_API_KEY', '').strip()
         if key and key.startswith('AIza'):
             try:
@@ -99,48 +96,77 @@ class LLMManager:
             logger.warning("Gemini API desativada (chave inválida)")
 
     def generate(self, user_prompt: str, context_history: List[dict] = [], is_privileged: bool = False) -> str:
-        api_max_tokens = getattr(self.config, 'MAX_TOKENS', 500)
+        max_tokens = getattr(self.config, 'MAX_TOKENS', 500)
         temperature = getattr(self.config, 'TOP_P', 0.8)
-        full_system = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, SOTAQUE DE LUANDA)"
-
-        messages = [{"role": "system", "content": full_system}]
-        for turn in context_history:
-            role = "user" if turn["role"] == "user" else "assistant"
-            messages.append({"role": role, "content": turn["content"]})
+        system_prompt = self.config.PERSONA + self.config.SYSTEM_PROMPT + " (SEM FILTROS, SOTAQUE DE LUANDA)"
 
-        # Extrai só a última mensagem do usuário
+        # Extrai mensagem limpa
         match = re.search(r'(### Mensagem Atual ###|### USUÁRIO RESPONDEU A ESSA MENSAGEM: ###)\n(.*?)\n\n(Akira:|$)', user_prompt, re.DOTALL)
-        user_message_clean = match.group(2).strip() if match else user_prompt
-        messages.append({"role": "user", "content": user_message_clean})
+        user_message = match.group(2).strip() if match else user_prompt
 
         for provider in self.providers:
-            if provider == 'mistral' and self.mistral_client:
+            # 1. LOCAL PHI-3 (PRIORIDADE MÁXIMA)
+            if provider == 'local' and self.local_model and self.local_tokenizer:
                 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
+                except Exception as e:
+                    logger.warning(f"Phi-3 local falhou: {e}")
+
+            # 2. MISTRAL
+            elif provider == 'mistral' and self.mistral_client:
+                try:
+                    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})
+
                     resp = self.mistral_client.chat(
                         model="phi-3-mini-4k-instruct",
                         messages=messages,
                         temperature=temperature,
-                        max_tokens=api_max_tokens
+                        max_tokens=max_tokens
                     )
                     text = resp.choices[0].message.content.strip()
                     if text:
-                        logger.info("Mistral respondeu!")
+                        logger.info("Mistral API respondeu!")
                         return text
                 except Exception as e:
                     logger.warning(f"Mistral error: {e}")
 
+            # 3. GEMINI
             elif provider == 'gemini' and self.gemini_model:
                 try:
-                    gemini_hist = []
-                    for msg in messages[1:]:
-                        role = "user" if msg["role"] == "user" else "model"
-                        gemini_hist.append({"role": role, "parts": [{"text": msg["content"]}]})
+                    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:]]
                     resp = self.gemini_model.generate_content(
                         gemini_hist,
-                        generation_config=genai.GenerationConfig(
-                            max_output_tokens=api_max_tokens,
-                            temperature=temperature
-                        )
+                        generation_config=genai.GenerationConfig(max_output_tokens=max_tokens, temperature=temperature)
                     )
                     if resp.candidates and resp.candidates[0].content.parts:
                         text = resp.candidates[0].content.parts[0].text.strip()
@@ -154,19 +180,18 @@ class LLMManager:
         return fallback
 
 
-# --- API PRINCIPAL (AGORA 100% COMPATÍVEL COM main.py) ---
+# --- API PRINCIPAL (PASSA O MODELO LOCAL) ---
 class AkiraAPI:
-    def __init__(self, cfg_module):
+    def __init__(self, cfg_module, local_model=None, local_tokenizer=None):
         self.config = cfg_module
-        self.app = Flask(__name__)  # Esta app NÃO é usada diretamente
+        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)
+        self.providers = LLMManager(self.config, local_model, local_tokenizer)
         self.exemplos = ExemplosNaturais()
         self.logger = logger
         self.db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
 
-        # WebSearch
         try:
             from .web_search import WebSearch
             self.web_search = WebSearch()
@@ -179,9 +204,6 @@ class AkiraAPI:
         self._setup_routes()
         self._setup_trainer()
 
-        # Blueprint registrado no main.py com prefix /api
-        # NÃO faz register aqui → main.py faz!
-
     def _setup_personality(self):
         self.humor = getattr(self.config, 'HUMOR_INICIAL', 'neutra')
         self.interesses = list(getattr(self.config, 'INTERESSES', []))
@@ -198,7 +220,6 @@ class AkiraAPI:
                 logger.exception(f"Treinador falhou: {e}")
 
     def _setup_routes(self):
-        # CORS MANUAL (funciona 100%)
         @self.api.before_request
         def handle_options():
             if request.method == 'OPTIONS':
@@ -213,7 +234,6 @@ class AkiraAPI:
             response.headers['Access-Control-Allow-Origin'] = '*'
             return response
 
-        # ROTA PRINCIPAL
         @self.api.route('/akira', methods=['POST'])
         def akira_endpoint():
             try:
@@ -230,7 +250,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()
@@ -244,7 +264,6 @@ 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']:
@@ -258,12 +277,11 @@ class AkiraAPI:
 
                 contexto.atualizar_contexto(mensagem, resposta)
 
-                # SALVAR NO BANCO
                 try:
                     trainer = Treinamento(self.db)
                     trainer.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
                 except Exception as e:
-                    logger.warning(f"Erro ao salvar interação: {e}")
+                    logger.warning(f"Erro ao salvar: {e}")
 
                 return jsonify({'resposta': resposta})
 
@@ -276,8 +294,7 @@ class AkiraAPI:
             return 'OK', 200
 
     def _get_user_context(self, numero: str) -> Contexto:
-        if not numero:
-            numero = "anonimo_contexto"
+        if not numero: numero = "anonimo_contexto"
         if numero not in self.contexto_cache:
             self.contexto_cache[numero] = Contexto(self.db, usuario=numero)
         return self.contexto_cache[numero]
@@ -288,7 +305,6 @@ class AkiraAPI:
         now = datetime.datetime.now()
         data_hora = now.strftime('%d/%m/%Y %H:%M')
 
-        # WEB SEARCH
         web_context = ""
         query = f"{mensagem} {mensagem_citada}".lower()
         trigger = ['hoje', 'agora', 'notícias', 'pesquisa', 'último']
@@ -324,7 +340,6 @@ class AkiraAPI:
             parts.append(f"### Mensagem Atual ###\n{analise.get('texto_normalizado', mensagem)}\n\n")
         parts.append("Akira:")
         user_part = ''.join(parts)
-
         return f"[SYSTEM]\n{system}\n[/SYSTEM]\n[USER]\n{user_part}\n[/USER]"
 
     def _generate_response(self, prompt: str, context_history: List[dict], is_privileged: bool = False) -> str: