Update app.py

app.py

@@ -7,6 +7,8 @@ import requests
 
 from flask import Flask, request, jsonify, send_file
 from gtts import gTTS
+# Importa Groq e Google GenAI
+from groq import Groq
 from google import genai
 from google.genai import types
 
@@ -15,22 +17,29 @@ from google.genai import types
 # Inicializa o Flask
 app = Flask(__name__)
 
-# --- CONFIGURAÇÃO DA API GEMINI ---
-# Tenta carregar a chave API da Gemini das variáveis de ambiente (Secrets do Hugging Face).
-# Se a chave não for encontrada, o cliente Gemini não será inicializado e o endpoint de tradução falhará.
+# --- CONFIGURAÇÃO DAS APIS LLM ---
+genai_client = None
+groq_client = None
+
+# 1. Configuração Gemini
 try:
     GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
     if GEMINI_API_KEY:
         genai_client = genai.Client(api_key=GEMINI_API_KEY)
     else:
-        genai_client = None
-        print("AVISO: GEMINI_API_KEY não configurada. A funcionalidade de Tradução/Contexto (clique duplo) será desativada.")
+        print("AVISO: GEMINI_API_KEY não configurada. Gemini estará desativado para análise.")
 except Exception as e:
-    genai_client = None
-    print(f"ERRO ao inicializar o cliente Gemini: {e}. A funcionalidade de IA será desativada.")
+    print(f"ERRO ao inicializar o cliente Gemini: {e}. Funcionalidade de IA desativada.")
 
-# Modelo para contextualização de texto e tradução
-GEMINI_MODEL = "gemini-2.5-flash"
+# 2. Configuração Groq
+try:
+    GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+    if GROQ_API_KEY:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+    else:
+        print("AVISO: GROQ_API_KEY não configurada. Groq estará desativado.")
+except Exception as e:
+    print(f"ERRO ao inicializar o cliente Groq: {e}. Funcionalidade de IA desativada.")
 
 
 # --- ROTA 1: TEXT-TO-SPEECH (TTS) - USANDO gTTS GRATUITO ---
@@ -47,14 +56,11 @@ def tts_proxy():
     if not text:
         return jsonify({"error": "No text provided"}), 400
 
-    # O gTTS não suporta o controle de velocidade granular via API, mas é o melhor
-    # compromisso para um serviço gratuito.
-
     try:
-        # Cria um objeto gTTS
+        # Cria um objeto gTTS (sem controle de velocidade)
         tts = gTTS(text=text, lang='en', tld='us') # TLD 'us' para sotaque Americano
 
-        # Salva o áudio em um buffer de bytes na memória (Melhor que salvar no disco)
+        # Salva o áudio em um buffer de bytes na memória
         mp3_fp = io.BytesIO()
         tts.write_to_fp(mp3_fp)
         mp3_fp.seek(0)
@@ -72,73 +78,144 @@ def tts_proxy():
         return jsonify({"error": f"Failed to generate audio via gTTS: {e}"}), 500
 
 
-# --- ROTA 2: TRADUÇÃO RÁPIDA E CONTEXTO (IA) - USANDO GEMINI (REQUER CHAVE) ---
+# --- ROTA 2: TRADUÇÃO RÁPIDA E CONTEXTO (IA) - USANDO GEMINI OU GROQ ---
+
+def get_ai_response(provider, model_name, system_instruction, json_schema=None):
+    """Função auxiliar para rotear a requisição LLM para o provedor selecionado."""
+    
+    if provider == 'gemini':
+        if not genai_client:
+            raise Exception("Gemini client not initialized. GEMINI_API_KEY is missing.")
+
+        # O Gemini usa um prompt simples com schema
+        contents=[system_instruction]
+        
+        # Configuração para resposta JSON estruturada (usada para flashcards)
+        config = types.GenerateContentConfig()
+        if json_schema:
+             config = types.GenerateContentConfig(
+                response_mime_type="application/json",
+                response_schema=json_schema
+            )
+        
+        response = genai_client.models.generate_content(
+            model=model_name,
+            contents=contents,
+            config=config
+        )
+        
+        if json_schema:
+            # Retorna o JSON parsado
+            if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
+                json_text = response.candidates[0].content.parts[0].text.strip()
+                return json.loads(json_text)
+            else:
+                 raise Exception("Gemini returned empty or invalid JSON content.")
+        else:
+            # Retorna o texto simples
+            return response.text.strip()
+
+    elif provider == 'groq':
+        if not groq_client:
+            raise Exception("Groq client not initialized. GROQ_API_KEY is missing.")
+
+        # Para Groq, a instrução do sistema é o conteúdo
+        messages = [
+            {"role": "system", "content": system_instruction}
+        ]
+        
+        # Configuração para resposta JSON
+        config_params = {}
+        if json_schema:
+            config_params['response_format'] = {"type": "json_object"}
+
+        response = groq_client.chat.completions.create(
+            model=model_name,
+            messages=messages,
+            **config_params
+        )
+
+        text_response = response.choices[0].message.content.strip()
+
+        if json_schema:
+            # Retorna o JSON parsado
+            return json.loads(text_response)
+        else:
+            # Retorna o texto simples
+            return text_response
+            
+    else:
+        raise Exception(f"Unsupported provider: {provider}")
+
 
 @app.route('/explain-proxy', methods=['POST'])
 def explain_proxy():
     """
-    Usa o modelo Gemini para fornecer explicação em inglês e tradução em português
-    para uma palavra/frase em contexto.
-    Pode retornar em JSON simples para o modal ou em JSON estruturado para flashcards.
+    Usa o modelo LLM selecionado para fornecer explicação e tradução.
     """
     data = request.get_json()
     word = data.get('word', '').strip()
     context = data.get('context', '')
-    for_flashcard = data.get('for_flashcard', False) # True se for para criar um flashcard
+    for_flashcard = data.get('for_flashcard', False)
+    # Novo: Captura o provedor e o modelo selecionados
+    model_provider, model_name = data.get('model', 'gemini:gemini-2.5-flash').split(':', 1)
 
-    if not genai_client:
-        return jsonify({"error": "GEMINI_API_KEY not configured. Cannot perform AI analysis."}), 503
-    
     if not word:
         return jsonify({"error": "No word or phrase selected."}), 400
 
-    # Define o System Instruction base
-    system_instruction_base = f"You are a professional English tutor and linguist. Your task is to analyze the user-provided English word or phrase: '{word}' in its context: '{context}'. All responses must be highly accurate and relevant to language learning. Only output the final JSON object."
+    if model_provider == 'gemini' and not genai_client:
+        return jsonify({"error": "GEMINI_API_KEY not configured. Cannot perform AI analysis."}), 503
+    if model_provider == 'groq' and not groq_client:
+        return jsonify({"error": "GROQ_API_KEY not configured. Cannot perform AI analysis."}), 503
+
+
+    system_instruction_base = f"You are a professional English tutor and linguist. Your task is to analyze the user-provided English word or phrase: '{word}' in its context: '{context}'. All responses must be highly accurate and relevant to language learning."
+
+    # Define o schema JSON para Flashcards
+    flashcard_schema = {
+        "type": "OBJECT",
+        "properties": {
+            "term": {"type": "STRING", "description": "The selected word or phrase."},
+            "explanation": {"type": "STRING", "description": "A clear English definition or explanation."},
+            "translation": {"type": "STRING", "description": "The accurate Portuguese translation of the term/phrase."},
+            "example": {"type": "STRING", "description": "A new, helpful example sentence using the term/phrase."},
+        },
+        "required": ["term", "explanation", "translation", "example"]
+    }
 
     try:
         if for_flashcard:
             # 1. Requisição para Flashcard (JSON Estruturado)
             system_instruction = system_instruction_base + " You must generate a single, highly relevant example sentence using the word/phrase, and provide a clear, simple English definition. Translate the word/phrase accurately to Portuguese. The output MUST be a JSON object conforming to the provided schema."
             
-            response = genai_client.models.generate_content(
-                model=GEMINI_MODEL,
-                contents=[system_instruction],
-                config=types.GenerateContentConfig(
-                    response_mime_type="application/json",
-                    response_schema={
-                        "type": "OBJECT",
-                        "properties": {
-                            "term": {"type": "STRING", "description": "The selected word or phrase."},
-                            "explanation": {"type": "STRING", "description": "A clear English definition or explanation."},
-                            "translation": {"type": "STRING", "description": "The accurate Portuguese translation of the term/phrase."},
-                            "example": {"type": "STRING", "description": "A new, helpful example sentence using the term/phrase."},
-                        },
-                        "required": ["term", "explanation", "translation", "example"]
-                    }
-                )
+            # Para Groq, adicionamos a descrição do schema no prompt
+            if model_provider == 'groq':
+                system_instruction += f" The JSON object must follow this structure: {json.dumps(flashcard_schema)}"
+
+            card_data = get_ai_response(
+                model_provider, 
+                model_name, 
+                system_instruction, 
+                json_schema=flashcard_schema if model_provider == 'gemini' else flashcard_schema # Schema passado para Gemini, ou estrutura para Groq
             )
             
-            # O retorno do Gemini é uma string JSON, que precisamos analisar
-            if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
-                json_text = response.candidates[0].content.parts[0].text.strip()
-                # O cliente no frontend espera "term", "translation", "example"
-                # O campo "explanation" é a definição em inglês.
-                card_data = json.loads(json_text)
+            # Verifica se os campos essenciais estão presentes no retorno do LLM
+            if card_data and card_data.get('term') and card_data.get('translation') and card_data.get('example'):
                 return jsonify(card_data)
             else:
-                raise Exception("AI returned empty or invalid content for flashcard.")
+                raise Exception("AI returned empty or invalid structured data.")
                 
         else:
             # 2. Requisição para Modal (Explicação e Tradução Simples)
-            prompt = f"For the term '{word}' in the context: '{context}', provide a clear, one-sentence English explanation/definition, followed by an exact Portuguese translation, separated by a distinct marker like '---'.\nExample Format:\nDefinition in English.\n---\nTradução em Português."
+            prompt = system_instruction_base + f" Provide a clear, one-sentence English explanation/definition, followed by an exact Portuguese translation, separated by a distinct marker like '---'.\nExample Format:\nDefinition in English.\n---\nTradução em Português."
             
-            response = genai_client.models.generate_content(
-                model=GEMINI_MODEL,
-                contents=[prompt],
-                config=types.GenerateContentConfig()
+            text_response = get_ai_response(
+                model_provider, 
+                model_name, 
+                prompt,
+                json_schema=None # Não é JSON estruturado
             )
-
-            text_response = response.text.strip()
+            
             parts = text_response.split('---', 1)
             
             explanation = parts[0].strip()