Update modules/api.py

modules/api.py

@@ -4,39 +4,41 @@ API wrapper for Akira service - VERSÃO FINAL ADAPTADA:
 - Pesquisa web (SerpAPI)
 - Nome: probabilidade 0.4 + pronomes por tom
 - PRINCIPAL: MISTRAL AI API
-- Fallback: Llama 3.1 8B local → Gemini
+- Fallback: Llama 3.1 8B local (CPU 8-bit) → Gemini
 - Prompt otimizado com contexto angolano
 """
 from typing import Dict, Optional, Any
 import time
-import logging
 import re
 import datetime
 import random
 from flask import Flask, Blueprint, request, jsonify
-
+from loguru import logger
+import modules.config as config
 from .contexto import Contexto
 from .database import Database
 from .treinamento import Treinamento
 from .web_search import WebSearch
 from .local_llm import LlamaLLM
 
+# Verifica disponibilidade
 try:
     from mistralai import Mistral
     mistral_available = True
 except ImportError:
     mistral_available = False
+    logger.warning("mistralai não instalado")
 
 try:
     import google.generativeai as genai
     gemini_available = True
 except ImportError:
     gemini_available = False
+    logger.warning("google-generativeai não instalado")
 
-logger = logging.getLogger("akira.api")
 
 class LLMManager:
-    """Gerenciador de LLMs: MISTRAL API → Llama local → Gemini"""
+    """Gerenciador de LLMs: MISTRAL → Llama (CPU) → Gemini"""
     def __init__(self, config):
         self.config = config
         self.llama = LlamaLLM()
@@ -45,22 +47,22 @@ class LLMManager:
         self._setup_providers()
 
     def _setup_providers(self):
-        # MISTRAL API (PRINCIPAL)
-        if mistral_available and config.MISTRAL_API_KEY:
+        # MISTRAL API
+        if mistral_available and self.config.MISTRAL_API_KEY:
             try:
-                self.mistral_client = Mistral(api_key=config.MISTRAL_API_KEY)
-                logger.info("Mistral API client inicializado (principal).")
+                self.mistral_client = Mistral(api_key=self.config.MISTRAL_API_KEY)
+                logger.info("Mistral API inicializado (principal)")
             except Exception as e:
-                logger.warning(f"Falha ao inicializar Mistral: {e}")
+                logger.warning(f"Mistral falhou: {e}")
 
-        # GEMINI (FALLBACK 3)
-        if gemini_available and config.GEMINI_API_KEY:
+        # GEMINI
+        if gemini_available and self.config.GEMINI_API_KEY:
             try:
-                genai.configure(api_key=config.GEMINI_API_KEY)
-                self.gemini_model = genai.GenerativeModel(config.GEMINI_MODEL)
-                logger.info("Gemini model inicializado (fallback).")
+                genai.configure(api_key=self.config.GEMINI_API_KEY)
+                self.gemini_model = genai.GenerativeModel(self.config.GEMINI_MODEL)
+                logger.info("Gemini inicializado (fallback)")
             except Exception as e:
-                logger.warning(f"Falha ao inicializar Gemini: {e}")
+                logger.warning(f"Gemini falhou: {e}")
 
     def _limpar_resposta(self, texto: str) -> str:
         if not texto:
@@ -69,88 +71,79 @@ class LLMManager:
         texto = re.sub(r'\s+', ' ', texto.replace('\n', ' ')).strip()
         if len(texto) > 280:
             frases = [f.strip() for f in texto.split('. ') if f.strip()]
-            texto_curto = ""
-            for frase in frases:
-                if len(texto_curto + frase + ". ") <= 280:
-                    texto_curto += frase + ". "
+            curto = ""
+            for f in frases:
+                if len(curto + f + ". ") <= 280:
+                    curto += f + ". "
                 else:
                     break
-            texto = texto_curto.strip()
+            texto = curto.strip()
             if not texto.endswith(('.', '!', '?')):
                 texto += "..."
         return texto.strip()
 
     def generate(self, prompt: str, max_tokens: int = 500, temperature: float = 0.8) -> str:
         max_attempts = 6
-        attempt = 1
-        while attempt <= max_attempts:
-            # 1. MISTRAL API (PRINCIPAL)
+        for attempt in range(1, max_attempts + 1):
+            # 1. MISTRAL
             if self.mistral_client:
                 try:
-                    response = self.mistral_client.chat.complete(
-                        model=config.MISTRAL_MODEL,
+                    resp = self.mistral_client.chat.complete(
+                        model=self.config.MISTRAL_MODEL,
                         messages=[{"role": "user", "content": prompt}],
                         max_tokens=max_tokens,
                         temperature=temperature,
-                        top_p=config.TOP_P,
+                        top_p=self.config.TOP_P,
                     )
-                    text = response.choices[0].message.content
+                    text = resp.choices[0].message.content
                     if text:
-                        logger.info(f"Resposta com Mistral API (tentativa {attempt})")
+                        logger.info(f"Mistral OK (tentativa {attempt})")
                         return self._limpar_resposta(text)
                 except Exception as e:
                     if "429" in str(e):
                         time.sleep(2 ** (attempt % 3))
-                    logger.warning(f"Mistral falhou (tentativa {attempt}): {e}")
-                    attempt += 1
-                    continue
+                    logger.warning(f"Mistral erro {attempt}: {e}")
 
-            # 2. LLAMA LOCAL (FALLBACK 1)
+            # 2. LLAMA LOCAL (CPU 8-bit)
             if self.llama.model:
                 try:
                     resp = self.llama.generate(prompt, max_tokens)
                     if resp.strip():
-                        logger.info(f"Resposta com Llama 3.1 8B (tentativa {attempt})")
+                        logger.info(f"Llama OK (tentativa {attempt})")
                         return self._limpar_resposta(resp)
                 except Exception as e:
-                    logger.warning(f"Llama falhou (tentativa {attempt}): {e}")
-                    attempt += 1
-                    continue
+                    logger.warning(f"Llama erro {attempt}: {e}")
 
-            # 3. GEMINI (FALLBACK 2)
+            # 3. GEMINI
             if self.gemini_model:
                 try:
-                    response = self.gemini_model.generate_content(
+                    resp = self.gemini_model.generate_content(
                         prompt,
                         generation_config={
                             "max_output_tokens": max_tokens,
                             "temperature": temperature,
-                            "top_p": config.TOP_P,
+                            "top_p": self.config.TOP_P,
                         }
                     )
-                    text = response.text
+                    text = resp.text
                     if text:
-                        logger.info(f"Resposta com Gemini (tentativa {attempt})")
+                        logger.info(f"Gemini OK (tentativa {attempt})")
                         return self._limpar_resposta(text)
                 except Exception as e:
                     if "429" in str(e) or "quota" in str(e):
                         time.sleep(2 ** (attempt % 3))
-                    logger.warning(f"Gemini falhou (tentativa {attempt}): {e}")
-                    attempt += 1
-                    continue
+                    logger.warning(f"Gemini erro {attempt}: {e}")
 
-            # Fallback local simples
-            return "Tô com problema, puto. Tenta depois kkk"
+        logger.error("Todos LLMs falharam")
+        return self.config.FALLBACK_RESPONSE
 
-        logger.error("Todas tentativas falharam.")
-        return config.FALLBACK_RESPONSE
 
 class AkiraAPI:
     def __init__(self, cfg_module):
         self.config = cfg_module
         self.app = Flask(__name__)
         self.api = Blueprint("akira_api", __name__)
-        self.db = Database(getattr(self.config, 'DB_PATH', 'akira.db'))
+        self.db = Database(getattr(self.config, 'DB_PATH', '/app/data/akira.db'))
         self.contexto_cache = {}
         self.providers = LLMManager(self.config)
         self.treinador = Treinamento(self.db)
@@ -170,47 +163,40 @@ class AkiraAPI:
 
     def _get_pronomes_por_tom(self, tom: str) -> str:
         result = self.db._execute_with_retry(
-            "SELECT pronomes FROM pronomes_por_tom WHERE tom=?", (tom,)
+            "SELECT pronomes FROM pronomes_por_tom WHERE tom=?", (tom.lower(),)
         )
         return result[0][0] if result else ""
 
     def _build_prompt(self, usuario: str, numero: str, mensagem: str, analise: dict,
-                      contexto: Contexto, is_blocking: bool, is_privileged: bool,
-                      is_reply: bool, mensagem_original: str) -> str:
-        # DATA E HORA COM ANO
+                      contexto: Contexto, is_privileged: bool, is_reply: bool, mensagem_original: str) -> str:
         data_hora = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
-        # NOTÍCIAS ATUAIS (Angola)
         noticias = self.web_search.pesquisar_noticias_angola()
-        # TOM DO USUÁRIO
         tom_usuario = contexto.ton_predominante or "neutro"
         pronomes = self._get_pronomes_por_tom(tom_usuario)
-        # REGRAS NATURAIS
+        girias_user = ", ".join([g['giria'] for g in contexto.girias_aprendidas[:3]])
+
         strict = f"""
 REGRAS OBRIGATÓRIAS:
-- RESPONDA COMO PESSOA, NUNCA COMO IA
-- MÁXIMO 1-2 FRASES CURTAS
-- USE GÍRIAS NATURAIS: bué, fixe, puto, oroh, mwangolé, kota
-- SEJA DIRETA, SARCÁSTICA SE QUISER
-- USE "kkk", "rsrs", "aff" para rir
-- NUNCA use negrito, itálico ou markdown
-- NUNCA diga "como IA", "modelo", "sistema"
-- USE NOME DO USUÁRIO SÓ ~40% DAS VEZES
-- NUNCA NCA use nome completo (ex: "Isaac Quarenta")
-- Usuários privilegiados: use apenas o último nome (ex: "Quarenta")
-- DATA ATUAL: {data_hora}
-# NOTÍCIAS ATUAIS (Angola):
+- FALE COMO GENTE, NUNCA COMO IA
+- 1-2 FRASES CURTAS
+- GÍRIAS: bué, fixe, puto, oroh, mwangolé, kota
+- SARCASMO OK
+- USE kkk, rsrs, aff
+- SEM markdown, negrito
+- USE NOME ~40% DAS VEZES
+- DATA: {data_hora}
+# NOTÍCIAS ANGOLA:
 {noticias}
-# PRONOMES POR TOM ({tom_usuario}):
+# PRONOMES ({tom_usuario}):
 {pronomes}
-# TOM ESPECÍFICO:
 """
         if is_privileged:
-            strict += "- TOM MAIS FORMAL COM ISAAC (use 'Sr.', 'boss', 'maior')\n"
+            strict += "- TOM FORMAL COM ISAAC: Sr., boss, maior\n"
         else:
-            strict += "- TOM NORMAL: fala como gente de Luanda\n"
+            strict += "- TOM NORMAL: fala de Luanda\n"
+
         hist = contexto.obter_historico()[-3:]
         hist_txt = "\n".join([f"U: {h[0]}\nA: {h[1]}" for h in hist]) if hist else ""
-        girias_user = ", ".join([g['giria'] for g in contexto.girias_aprendidas[:3]])
         user_info = f"""
 USUÁRIO:
 - Nome: {usuario}
@@ -219,10 +205,10 @@ USUÁRIO:
 - Gírias: {girias_user}
 - Privilégio: {'sim' if is_privileged else 'não'}
 """
+
         prompt = f"[SYSTEM]\n{strict}\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n[/SYSTEM]\n"
         prompt += f"[CONTEXTO]\n{hist_txt}\n{user_info}\n[/CONTEXTO]\n"
-        prompt += f"[MENSAGEM]\n{mensagem}\n[/MENSAGEM]\n"
-        prompt += "Akira:"
+        prompt += f"[MENSAGEM]\n{mensagem}\n[/MENSAGEM]\nAkira:"
         return prompt
 
     def _setup_routes(self):
@@ -237,8 +223,10 @@ USUÁRIO:
                 is_privileged = (usuario.lower() == 'isaac' or '244937035662' in numero)
                 is_reply = bool(data.get('is_reply') or data.get('mensagem_original'))
                 mensagem_original = data.get('mensagem_original') or data.get('quoted_message') or ''
+
                 if not mensagem.strip():
-                    return jsonify({'error': 'mensagem é obrigatória'}), 400
+                    return jsonify({'error': 'mensagem obrigatória'}), 400
+
                 logger.info(f"{usuario} ({numero}): {mensagem[:120]}")
                 contexto = self._get_user_context(usuario, numero)
                 analise = contexto.analisar_intencao_e_normalizar(mensagem, contexto.obter_historico())
@@ -247,22 +235,25 @@ USUÁRIO:
                     is_privileged, is_reply, mensagem_original
                 )
                 resposta = self.providers.generate(prompt, max_tokens=500, temperature=0.8)
+
                 if random.random() < getattr(self.config, 'USAR_NOME_PROBABILIDADE', 0.4):
-                    pass  # A IA decide sozinha
+                    pass  # IA decide
+
                 contexto.atualizar_contexto(mensagem, resposta)
                 self.treinador.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
+
                 return jsonify({
                     'resposta': resposta,
                     'aprendizados': {
                         'emocao_atual': contexto.emocao_atual,
                         'termos': contexto.termo_contexto,
-                        'gírias': [g['giria'] for g in contexto.gírias_aprendidas[:3]]
+                        'gírias': [g['giria'] for g in contexto.girias_aprendidas[:3]]
                     }
                 })
             except Exception as e:
                 logger.error(f"Erro fatal: {e}", exc_info=True)
-                return jsonify({'resposta': 'tive um erro, puto. tenta depois.'}), 500
+                return jsonify({'resposta': 'tive erro, puto. tenta depois.'}), 500
 
     def run(self, host='0.0.0.0', port=7860, debug=False):
-        logger.info(f"Starting Akira IA Flask app... Running on port {port}, debug={'ON' if debug else 'OFF'}")
+        logger.info(f"Iniciando Flask na porta {port}")
         self.app.run(host=host, port=port, debug=debug, threaded=True)