Update app.py

app.py

@@ -1,3 +1,4 @@
+#app.py
 import os
 import io
 import json
@@ -23,9 +24,12 @@ groq_client = None
 
 # 1. Configuração Gemini
 try:
+    # Use os Secrets do Hugging Face para armazenar suas chaves
     GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
     if GEMINI_API_KEY:
-        genai_client = genai.Client(api_key=GEMINI_API_KEY)
+        # Apenas inicializa o cliente se a chave existir
+        genai.configure(api_key=GEMINI_API_KEY)
+        genai_client = genai
     else:
         print("AVISO: GEMINI_API_KEY não configurada. Gemini estará desativado para análise.")
 except Exception as e:
@@ -82,41 +86,35 @@ def tts_proxy():
 
 # --- ROTA 2: TRADUÇÃO RÁPIDA E CONTEXTO (IA) - USANDO GEMINI OU GROQ ---
 
-def get_ai_response(provider, model_name, system_instruction, custom_prompt=None, json_schema=None):
+def get_ai_response(provider, model_name, system_instruction, user_prompt, json_schema=None):
     """Função auxiliar para rotear a requisição LLM para o provedor selecionado."""
     
-    # O prompt base é o system_instruction, a menos que custom_prompt seja fornecido
-    prompt_to_use = custom_prompt if custom_prompt else system_instruction
-    
     if provider == 'gemini':
         if not genai_client:
             raise Exception("Gemini client not initialized. GEMINI_API_KEY is missing.")
 
-        contents=[prompt_to_use]
+        model = genai_client.GenerativeModel(model_name)
         
         # Configuração para resposta JSON estruturada
-        config = types.GenerateContentConfig()
+        generation_config = None
         if json_schema:
-             config = types.GenerateContentConfig(
+             generation_config = genai.GenerationConfig(
                 response_mime_type="application/json",
                 response_schema=json_schema
             )
         
-        response = genai_client.models.generate_content(
-            model=model_name,
-            contents=contents,
-            config=config
+        response = model.generate_content(
+            user_prompt,
+            generation_config=generation_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':
@@ -125,10 +123,9 @@ def get_ai_response(provider, model_name, system_instruction, custom_prompt=None
 
         messages = [
             {"role": "system", "content": system_instruction},
-            {"role": "user", "content": prompt_to_use}
+            {"role": "user", "content": user_prompt}
         ]
         
-        # Configuração para resposta JSON
         config_params = {}
         if json_schema:
             config_params['response_format'] = {"type": "json_object"}
@@ -138,14 +135,11 @@ def get_ai_response(provider, model_name, system_instruction, custom_prompt=None
             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:
@@ -154,134 +148,98 @@ def get_ai_response(provider, model_name, system_instruction, custom_prompt=None
 
 @app.route('/explain-proxy', methods=['POST'])
 def explain_proxy():
-    """
-    Usa o modelo LLM selecionado para fornecer explicação, tradução, ou gerar atividades.
-    """
     data = request.get_json()
     word = data.get('word', '').strip()
-    context = data.get('context', '') # Contexto local da frase
+    context = data.get('context', '')
     for_flashcard = data.get('for_flashcard', False)
-    # Novos parâmetros do frontend
-    model_provider, model_name = data.get('model', 'gemini:gemini-2.5-flash').split(':', 1)
-    context_focus = data.get('context_focus', 'General/Social') # Novo: contexto profissional/social
-    custom_prompt = data.get('custom_prompt', None) # Novo: prompt para geração de atividades
+    model_provider, model_name = data.get('model', 'gemini:gemini-1.5-flash').split(':', 1)
+    context_focus = data.get('context_focus', 'General/Social')
+    custom_prompt = data.get('custom_prompt', None)
 
-    # 1. Checagem de disponibilidade e chaves
     if model_provider == 'gemini' and not genai_client:
-        return jsonify({"error": "GEMINI_API_KEY not configured. Cannot perform AI analysis."}), 503
+        return jsonify({"error": "GEMINI_API_KEY not configured."}), 503
     if model_provider == 'groq' and not groq_client:
-        return jsonify({"error": "GROQ_API_KEY not configured. Cannot perform AI analysis."}), 503
+        return jsonify({"error": "GROQ_API_KEY not configured."}), 503
 
-    # Define a instrução do sistema base para todas as tarefas de IA
-    system_instruction_base = f"You are a professional English tutor and linguist focused on the context '{context_focus}'. All responses must be highly accurate and relevant to language learning."
+    system_instruction_base = f"You are a professional English tutor focused on the context '{context_focus}'. All responses must be accurate and relevant to language learning."
 
-    # Se for uma requisição de Geração de Atividade (custom_prompt), use a instrução direta
     if custom_prompt:
         try:
-            # O get_ai_response usa o custom_prompt como conteúdo principal
             text_response = get_ai_response(
-                model_provider, 
-                model_name, 
+                model_provider, model_name, 
                 system_instruction=system_instruction_base, 
-                custom_prompt=custom_prompt,
+                user_prompt=custom_prompt,
                 json_schema=None
             )
-            # Para atividades, retornamos a resposta simples no campo 'explanation'
             return jsonify({
                 "explanation": text_response,
-                "translation": "Activity Generated." # Marcador para o frontend
+                "translation": "Activity Generated."
             })
         except Exception as e:
             print(f"Erro na geração de atividade: {e}")
             return jsonify({"error": f"AI activity generation failed: {e}"}), 500
 
-
-    # 2. Requisições de Contextualização (Clique Duplo/Flashcard)
     if not word:
         return jsonify({"error": "No word or phrase selected."}), 400
 
-    # Define o schema JSON para Flashcards
+    # Schema JSON aprimorado para o Flashcard Inteligente
     flashcard_schema = {
-        "type": "OBJECT",
+        "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, specifically tailored to the context of the user."},
+            "term": {"type": "string", "description": "The selected English word or phrase."},
+            "translation": {"type": "string", "description": "The accurate Portuguese translation to be used as a hint."},
+            "context_sentence": {"type": "string", "description": "The original, complete English sentence from the context."},
+            "gapped_sentence": {"type": "string", "description": "The context sentence with the term replaced by '______________'."},
+            "definition": {"type": "string", "description": "A concise, clear English definition of the term."},
         },
-        "required": ["term", "explanation", "translation", "example"]
+        "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]
     }
 
     try:
         if for_flashcard:
-            # 2a. Requisição para Flashcard (JSON Estruturado)
-            system_instruction = system_instruction_base + f" Analyze the term '{word}' in context: '{context}'. You must generate a single, highly relevant example sentence, and provide a clear, simple English definition. Translate the term/phrase accurately to Portuguese. The output MUST be a JSON object conforming to the provided schema."
+            # Prompt detalhado para gerar o flashcard
+            system_instruction = system_instruction_base + " Your task is to generate a JSON object for an 'intelligent flashcard'."
+            user_prompt = f"""
+            Analyze the term '{word}' found in the following sentence: '{context}'.
+            Based on this, generate a JSON object that follows the required schema.
+            - 'term' should be the exact word/phrase '{word}'.
+            - 'translation' must be its most accurate Portuguese translation in this context.
+            - 'context_sentence' is the full original sentence.
+            - 'gapped_sentence' is the original sentence, but replacing '{word}' with '______________'.
+            - 'definition' is a clear, single-sentence definition in English.
+            """
             
-            # 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 # Usa o schema definido
+                model_provider, model_name, 
+                system_instruction, user_prompt,
+                json_schema=flashcard_schema
             )
-            
-            # Verifica e retorna o JSON
-            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 structured data.")
+            return jsonify(card_data)
                 
-        else:
-            # 2b. Requisição para Modal (Explicação e Tradução Simples - Clique Duplo)
-            prompt = system_instruction_base + f" Analyze the term '{word}' in 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."
+        else: # Requisição para o Modal (Clique Duplo)
+            system_instruction = system_instruction_base
+            user_prompt = f"Analyze the term '{word}' in context: '{context}'. Provide a clear, one-sentence English explanation, followed by its Portuguese translation, separated by '---'."
             
             text_response = get_ai_response(
-                model_provider, 
-                model_name, 
-                prompt,
-                json_schema=None # Não é JSON estruturado
+                model_provider, model_name, 
+                system_instruction, user_prompt,
+                json_schema=None
             )
-            
             parts = text_response.split('---', 1)
-            
             explanation = parts[0].strip()
             translation = parts[1].strip() if len(parts) > 1 else 'Tradução não disponível.'
 
-            return jsonify({
-                "explanation": explanation,
-                "translation": translation
-            })
+            return jsonify({"explanation": explanation, "translation": translation})
 
     except Exception as e:
         print(f"Erro na análise de IA: {e}")
         return jsonify({"error": f"AI analysis failed: {e}"}), 500
 
-
 # --- ROTA DE INICIALIZAÇÃO E ARQUIVOS ESTÁTICOS ---
 
 @app.route('/')
-def serve_index():
-    """
-    Serve o arquivo index.html principal.
-    Necessário para o Hugging Face Spaces que usa a arquitetura Flask.
-    """
-    try:
-        # Tenta servir o index.html, que é o frontend
-        return app.send_static_file('index.html')
-    except Exception:
-        # Se não encontrar index.html, serve uma mensagem de erro simples
-        return "Frontend file (index.html) not found. Please ensure index.html is in the same directory as app.py.", 500
-
-# Se estiver usando o Flask, ele procura por arquivos estáticos na pasta 'static'.
-# Como o Hugging Face coloca tudo na raiz do app, podemos configurá-lo para servir
-# a partir do diretório atual se necessário, mas para esta aplicação simples
-# e o index.html na raiz, o método 'serve_index' acima é o mais direto.
-
-# Inicializa o servidor Flask
+def root():
+    return send_file('index.html')
+
 if __name__ == '__main__':
-    # Define o static_folder como o diretório atual para que o send_static_file funcione
-    app.static_folder = os.path.dirname(os.path.abspath(__file__))
     app.run(host='0.0.0.0', port=7860)