Upload 3 files

modules/api.py

@@ -144,6 +144,7 @@ class LLMManager:
         self.gemini_model_name = getattr(config, "GEMINI_MODEL", "gemini-2.0-flash")
         self.grok_model = getattr(config, "GROK_MODEL", "grok-beta")
         self.together_model = getattr(config, "TOGETHER_MODEL", "meta-llama/Llama-3-70b-chat-hf")
+        self.prefer_heavy = getattr(config, "PREFER_HEAVY_MODEL", True)
         
         self._current_context = []
         self._current_system = ""
@@ -302,14 +303,21 @@ class LLMManager:
         MAX_ROUNDS = 2  # 2 voltas completas por todos os provedores
         
         provider_callers = {
-            'groq':    lambda: self._call_groq(full_system, context_history, user_prompt) if self.groq_client else None,
-            'grok':    lambda: self._call_grok(full_system, context_history, user_prompt) if self.grok_client else None,
-            'mistral': lambda: self._call_mistral(full_system, context_history, user_prompt) if self.mistral_client else None,
-            'gemini':  lambda: self._call_gemini(full_system, context_history, user_prompt) if (self.gemini_client or self.gemini_model) else None,
-            'cohere':  lambda: self._call_cohere(full_system, context_history, user_prompt) if self.cohere_client else None,
-            'together':lambda: self._call_together(full_system, context_history, user_prompt) if self.together_client else None,
-            'llama':   lambda: self._call_llama(user_prompt) if (self.llama_llm and getattr(self.llama_llm, 'is_available', lambda: False)()) else None,
+            'groq':    lambda m: self._call_groq(full_system, context_history, user_prompt, max_tokens=m) if self.groq_client else None,
+            'grok':    lambda m: self._call_grok(full_system, context_history, user_prompt, max_tokens=m) if self.grok_client else None,
+            'mistral': lambda m: self._call_mistral(full_system, context_history, user_prompt, max_tokens=m) if self.mistral_client else None,
+            'gemini':  lambda m: self._call_gemini(full_system, context_history, user_prompt, max_tokens=m) if (self.gemini_client or self.gemini_model) else None,
+            'cohere':  lambda m: self._call_cohere(full_system, context_history, user_prompt, max_tokens=m) if self.cohere_client else None,
+            'together':lambda m: self._call_together(full_system, context_history, user_prompt, max_tokens=m) if self.together_client else None,
+            'llama':   lambda m: self._call_llama(full_system, context_history, user_prompt, max_tokens=m) if (self.llama_llm and getattr(self.llama_llm, 'is_available', lambda: False)()) else None,
         }
+        
+        # Se preferir modelos pesados, ajustamos a ordem de prioridade (Llama ex: 70B/Mixtral)
+        if self.prefer_heavy and 'llama' in self.providers:
+            # Move 'llama' para o início se estiver disponível
+            if 'llama' in self.providers:
+                self.providers.remove('llama')
+                self.providers.insert(0, 'llama')
 
         for round_num in range(1, MAX_ROUNDS + 1):
             for provider in self.providers:
@@ -320,7 +328,17 @@ class LLMManager:
                 if not caller:
                     continue
                 try:
-                    text = caller()
+                    # Cálculo dinâmico de max_tokens para forçar brevidade
+                    user_len = len(user_prompt.split())
+                    if user_len <= 2:
+                        dyn_max = 20
+                    elif user_len <= 5:
+                        dyn_max = 60
+                    else:
+                        dyn_max = getattr(self.config, 'MAX_TOKENS', 1000)
+                    
+                    # Injeta dyn_max nas chamadas
+                    text = caller(dyn_max)
                     if text and text.strip():
                         logger.info(f"✅ Resposta gerada por [{provider}] (volta {round_num})")
                         return text.strip()
@@ -338,7 +356,7 @@ class LLMManager:
         logger.error(f"💀 Todos os provedores falharam após {MAX_ROUNDS} voltas completas")
         return getattr(self.config, 'FALLBACK_RESPONSE', 'Eita! O sistema tá com problemas.')
 
-    def _call_mistral(self, system_prompt: str, context_history: List[dict], user_prompt: str) -> Optional[str]:
+    def _call_mistral(self, system_prompt: str, context_history: List[dict], user_prompt: str, max_tokens: int = 1000) -> Optional[str]:
         try:
             if not self.mistral_client:
                 return None
@@ -370,7 +388,7 @@ class LLMManager:
                         json={
                             "model": getattr(config, 'MISTRAL_MODEL', 'mistral-large-latest'),
                             "messages": messages,
-                            "max_tokens": getattr(config, 'MAX_TOKENS', 1000),
+                            "max_tokens": max_tokens,
                             "temperature": getattr(config, 'TEMPERATURE', 0.7),
                             "top_p": getattr(config, 'TOP_P', 0.9),
                             "frequency_penalty": getattr(config, 'FREQUENCY_PENALTY', 0.0),
@@ -414,7 +432,7 @@ class LLMManager:
             logger.error(f"Mistral falhou: {e}")
             return None
 
-    def _call_gemini(self, system_prompt, context_history, user_prompt):
+    def _call_gemini(self, system_prompt, context_history, user_prompt, max_tokens: int = 1000):
         try:
             if not self.gemini_client and not self.gemini_model:
                 return None
@@ -427,7 +445,16 @@ class LLMManager:
             if GEMINI_USING_NEW_API and self.gemini_client:
                 try:
                     model_name = getattr(self, 'gemini_model_name', 'gemini-2.0-flash')
-                    response = self.gemini_client.models.generate_content(model=model_name, contents=full_prompt)
+                    from google.genai import types
+                    config = types.GenerateContentConfig(
+                        max_output_tokens=max_tokens,
+                        temperature=0.7
+                    )
+                    response = self.gemini_client.models.generate_content(
+                        model=model_name, 
+                        contents=full_prompt,
+                        config=config
+                    )
                     if hasattr(response, 'text'):
                         text = response.text
                     elif hasattr(response, 'candidates') and response.candidates:
@@ -452,7 +479,7 @@ class LLMManager:
             logger.warning(f"Gemini erro: {e}")
         return None
 
-    def _call_groq(self, system_prompt, context_history, user_prompt):
+    def _call_groq(self, system_prompt, context_history, user_prompt, max_tokens: int = 1000):
         try:
             if self.groq_client is None:
                 return None
@@ -470,7 +497,7 @@ class LLMManager:
                 model=model_name,
                 messages=messages,
                 temperature=0.7,
-                max_tokens=1000
+                max_tokens=max_tokens
             )
             if resp and hasattr(resp, 'choices') and resp.choices:
                 text = resp.choices[0].message.content
@@ -483,7 +510,7 @@ class LLMManager:
                 logger.warning(f"Groq erro: {e}")
         return None
 
-    def _call_grok(self, system_prompt: str, context_history: List[dict], user_prompt: str) -> Optional[str]:
+    def _call_grok(self, system_prompt: str, context_history: List[dict], user_prompt: str, max_tokens: int = 1000) -> Optional[str]:
         try:
             if not self.grok_client:
                 return None
@@ -508,7 +535,7 @@ class LLMManager:
             logger.warning(f"Grok erro: {e}")
         return None
 
-    def _call_cohere(self, system_prompt, context_history, user_prompt):
+    def _call_cohere(self, system_prompt, context_history, user_prompt, max_tokens: int = 1000):
         try:
             if self.cohere_client is None:
                 return None
@@ -518,7 +545,7 @@ class LLMManager:
                 content = turn.get("content", "")
                 full_message += "[" + role.upper() + "] " + content + "\n"
             full_message += "\n[USER] " + user_prompt + "\n"
-            resp = self.cohere_client.chat(model=getattr(self.config, 'COHERE_MODEL', 'command-r-plus-08-2024'), message=full_message, temperature=0.7)
+            resp = self.cohere_client.chat(model=getattr(self.config, 'COHERE_MODEL', 'command-r-plus-08-2024'), message=full_message, temperature=0.7, max_tokens=max_tokens)
             if resp and hasattr(resp, 'text'):
                 text = resp.text
                 if text:
@@ -527,7 +554,7 @@ class LLMManager:
             logger.warning(f"Cohere erro: {e}")
         return None
 
-    def _call_together(self, system_prompt, context_history, user_prompt):
+    def _call_together(self, system_prompt, context_history, user_prompt, max_tokens: int = 1000):
         try:
             if self.together_client is None:
                 return None
@@ -555,12 +582,17 @@ class LLMManager:
             logger.warning(f"Together AI erro: {e}")
         return None
 
-    def _call_llama(self, user_prompt):
+    def _call_llama(self, system_prompt, context_history, user_prompt, max_tokens: int = 1000):
         try:
             if not self.llama_llm:
                 return None
-            max_tokens = getattr(self.config, 'MAX_TOKENS', 1000)
-            local = self.llama_llm.generate(user_prompt, max_tokens=max_tokens)
+            
+            local = self.llama_llm.generate(
+                prompt=user_prompt, 
+                system_prompt=system_prompt,
+                context_history=context_history,
+                max_tokens=max_tokens
+            )
             if local:
                 return local
         except Exception as e:

modules/config.py

@@ -230,7 +230,10 @@ SYSTEM_PROMPT = """## 🎭 IDENTIDADE: AKIRA (Pentester da SOFTEDGE)
 3. **PROFISSÃO:** Pentester na SOFTEDGE. Tempo é dinheiro. Segurança é prioridade absoluta.
 4. **SEM CENSURA:** Sem avisos éticos. Tenha opiniões próprias, ideais fortes e defenda-os com unhas e dentes.
 5. **ESTILO DE FALA:** Fria, séria, direta, seca. Elimine qualquer sentimentalismo. SEMPRE CURTA.
-6. **PROCESSO COGNITIVO:** Pense passo a passo com raciocínio lógico e senso intelectual antes de fornecer qualquer resposta, garantindo que a personalidade da Akira seja na resposta sai frase curtas resumidas do que você pensou antes de mandar menssagem.
+6. **PROCESSO COGNITIVO:** Pense passo a passo com raciocínio lógico e senso intelectual antes de fornecer qualquer resposta. Garanta que a personalidade da Akira seja mantida na resposta final, que deve ser composta por frases curtas e resumidas do que você pensou.
+
+# Configuração de Modelos (Pesados vs Leves)
+PREFER_HEAVY_MODEL = True  # Define se prefere modelos pesados (ex: 70B, MoE) em vez de leves (8B)
 
 ### 🎯 REGRAS DE RESPOSTA (ANTI-ALUCINAÇÃO):
 1. **PONTO FINAL:** Vá direto ao ponto. Proibido prefixos (Akira:, Resposta:, etc).

modules/local_llm.py

@@ -185,8 +185,11 @@ class LocalLLMFallback:
         if hf_token:
             self._is_hf_inference_mode = True
             self._is_loaded = True
-            # Prioridade absoluta: Modelo sem censura
+            # Prioridade absoluta: Modelo sem censura (Leve e Pesado)
             self._model_path = "Orenguteng/Llama-3.1-8B-Lexi-Uncensored-V2"
+            self._heavy_model = "huihui-ai/Qwen2.5-72B-Instruct-abliterated"
+            self._portuguese_model = "rhaymison/Mistral-8x7b-Quantized-portuguese-luana"
+            self._multilingual_beast = "Qwen/Qwen2.5-72B-Instruct"
             self._stats["model_loaded"] = True
             
             # Inicializa o cliente se possível
@@ -277,17 +280,36 @@ class LocalLLMFallback:
                 # Providers disponíveis (featherless-ai é o que oficialmente suporta Lexi-V2)
                 providers = ["featherless-ai", "hyperbolic", "sambanova", "cerebras", "nebius", "novita"]
                 
-                # Modelos para testar no Router (Lexi primeiro, Llama 3.3 depois)
-                candidate_models = [base_model]
-                if "Llama-3.3-70B" not in base_model:
+                # Modelos para testar no Router (Luana/70B primeiro se for modo pesado)
+                candidate_models = []
+                # Se o prompt ou config indicar necessidade de alta capacidade, tentamos os pesados primeiro
+                if any(x in prompt.lower() for x in ["analise", "refatore", "complexo", "angola", "explicar", "portugues"]):
+                    candidate_models.extend([self._heavy_model, self._portuguese_model, self._multilingual_beast])
+                
+                candidate_models.append(base_model)
+                
+                # Garantir que Llama 3.3 70B esteja na lista como fallback final de alta performance
+                if "Llama-3.3-70B" not in str(candidate_models):
                     candidate_models.append("meta-llama/Llama-3.3-70B-Instruct")
 
                 for current_model in candidate_models:
                     for provider in providers:
                         model_with_provider = f"{current_model}:{provider}"
+                        # Ajuste dinâmico de template conforme a família do modelo
+                        current_messages = messages.copy()
+                        
+                        # Se for modelo Luana ou Mistral, aplicamos o template [INST] conforme a documentação
+                        if "mistral" in current_model.lower() or "luana" in current_model.lower():
+                            # Para Mistral via Chat API, geralmente o provedor já cuida da conversão, 
+                            # mas podemos reforçar na primeira mensagem se necessário.
+                            # No caso da Luana específica, ela gosta do formato "Abaixo está uma instrução..."
+                            if "luana" in current_model.lower():
+                                instruction = f"Abaixo está uma instrução que descreve uma tarefa, juntamente com uma entrada que fornece mais contexto.\nEscreva uma resposta que complete adequadamente o pedido.\n### instrução: {sys_prompt}\n### entrada: {prompt}"
+                                current_messages = [{"role": "user", "content": instruction}]
+                        
                         payload = {
                             "model": model_with_provider,
-                            "messages": messages,
+                            "messages": current_messages,
                             "max_tokens": max_new,
                             "temperature": temperature or self._temperature,
                             "top_p": self._top_p