Update app.py

app.py

@@ -2,11 +2,12 @@
 import os
 import io
 import json
+import base64
+from PIL import Image
 
 from flask import Flask, request, jsonify, send_file
 from gtts import gTTS
 from groq import Groq
-# CORREÇÃO: A importação correta para a biblioteca do Google Generative AI
 import google.generativeai as genai
 
 # --- CONFIGURAÇÃO INICIAL ---
@@ -23,10 +24,10 @@ try:
         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.")
+        print("AVISO: GEMINI_API_KEY não configurada.")
 except Exception as e:
     genai_client = None
-    print(f"ERRO ao inicializar o cliente Gemini: {e}. Funcionalidade de IA desativada.")
+    print(f"ERRO ao inicializar o cliente Gemini: {e}.")
 
 # 2. Configuração Groq
 try:
@@ -34,15 +35,16 @@ try:
     if GROQ_API_KEY:
         groq_client = Groq(api_key=GROQ_API_KEY)
     else:
-        print("AVISO: GROQ_API_KEY não configurada. Groq estará desativado.")
+        print("AVISO: GROQ_API_KEY não configurada.")
 except Exception as e:
     groq_client = None
-    print(f"ERRO ao inicializar o cliente Groq: {e}. Funcionalidade de IA desativada.")
+    print(f"ERRO ao inicializar o cliente Groq: {e}.")
 
 
-# --- ROTA 1: TEXT-TO-SPEECH (TTS) - USANDO gTTS GRATUITO ---
+# --- ROTA 1: TEXT-TO-SPEECH (TTS) ---
 @app.route('/tts-proxy', methods=['POST'])
 def tts_proxy():
+    # ... (código existente sem alterações) ...
     data = request.get_json()
     text = data.get('text', '')
     if not text:
@@ -58,51 +60,15 @@ 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 OU GROQ ---
-def get_ai_response(provider, model_name, system_instruction, user_prompt, json_schema=None):
-    if provider == 'gemini':
-        if not genai_client:
-            raise Exception("Gemini client not initialized. GEMINI_API_KEY is missing.")
-        model = genai_client.GenerativeModel(model_name)
-        
-        # CORREÇÃO: A configuração de geração para JSON agora é um dicionário simples
-        generation_config = None
-        if json_schema:
-             generation_config = {
-                "response_mime_type": "application/json",
-                "response_schema": json_schema
-            }
-        
-        response = model.generate_content(user_prompt, generation_config=generation_config)
-        
-        if json_schema:
-            json_text = response.candidates[0].content.parts[0].text.strip()
-            return json.loads(json_text)
-        else:
-            return response.text.strip()
-
-    elif provider == 'groq':
-        if not groq_client:
-            raise Exception("Groq client not initialized. GROQ_API_KEY is missing.")
-        messages = [{"role": "system", "content": system_instruction}, {"role": "user", "content": user_prompt}]
-        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()
-        return json.loads(text_response) if json_schema else text_response
-            
-    else:
-        raise Exception(f"Unsupported provider: {provider}")
-
-
+# --- ROTA 2: ANÁLISE DE TEXTO (FLASHCARDS, ETC.) ---
 @app.route('/explain-proxy', methods=['POST'])
 def explain_proxy():
+    # ... (código existente sem alterações) ...
     data = request.get_json()
+    model_provider, model_name = data.get('model', 'gemini:gemini-1.5-flash-latest').split(':', 1)
     word = data.get('word', '').strip()
     context = data.get('context', '')
     for_flashcard = data.get('for_flashcard', False)
-    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)
 
@@ -114,7 +80,7 @@ def explain_proxy():
 
     try:
         if custom_prompt:
-            text_response = get_ai_response(model_provider, model_name, system_instruction_base, custom_prompt)
+            text_response = get_ai_text_response(model_provider, model_name, system_instruction_base, custom_prompt)
             return jsonify({"explanation": text_response, "translation": "Activity Generated."})
 
         if not word:
@@ -122,23 +88,21 @@ def explain_proxy():
 
         if for_flashcard:
             flashcard_schema = {
-                "type": "object",
-                "properties": {
+                "type": "object", "properties": {
                     "term": {"type": "string"}, "translation": {"type": "string"},
                     "context_sentence": {"type": "string"}, "gapped_sentence": {"type": "string"},
                     "definition": {"type": "string"},
-                },
-                "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]
+                }, "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]
             }
             system_instruction = system_instruction_base + " Your task is to generate a JSON object for an 'intelligent flashcard'."
             user_prompt = f"Analyze the term '{word}' in the sentence: '{context}'. Generate a JSON object following the schema. The 'gapped_sentence' must replace '{word}' with '______________'."
-            card_data = get_ai_response(model_provider, model_name, system_instruction, user_prompt, json_schema=flashcard_schema)
+            card_data = get_ai_text_response(model_provider, model_name, system_instruction, user_prompt, json_schema=flashcard_schema)
             return jsonify(card_data)
                 
         else:
             system_instruction = system_instruction_base
             user_prompt = f"Analyze '{word}' in context: '{context}'. Provide a one-sentence English explanation, then '---', then the Portuguese translation."
-            text_response = get_ai_response(model_provider, model_name, system_instruction, user_prompt)
+            text_response = get_ai_text_response(model_provider, model_name, system_instruction, user_prompt)
             parts = text_response.split('---', 1)
             explanation = parts[0].strip()
             translation = parts[1].strip() if len(parts) > 1 else 'Tradução não disponível.'
@@ -148,7 +112,98 @@ def explain_proxy():
         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 ---
+# --- ROTA 3: ANÁLISE DE IMAGEM ---
+@app.route('/analyze-image', methods=['POST'])
+def analyze_image():
+    # ... (código existente sem alterações) ...
+    if not genai_client:
+        return jsonify({"error": "GEMINI_API_KEY not configured for image analysis."}), 503
+        
+    data = request.get_json()
+    base64_image = data.get('image')
+    if not base64_image:
+        return jsonify({"error": "No image data provided."}), 400
+
+    try:
+        image_data = base64.b64decode(base64_image.split(',')[1])
+        image = Image.open(io.BytesIO(image_data))
+        model = genai_client.GenerativeModel('gemini-1.5-flash-latest')
+
+        vocabulary_schema = { "type": "object", "properties": { "vocabulary": { "type": "array", "items": { "type": "object", "properties": { "term": {"type": "string"}, "definition": {"type": "string"} }, "required": ["term", "definition"] } } }, "required": ["vocabulary"] }
+        prompt = [ "You are an English teacher. Look at this image and identify 5 to 7 key objects or concepts. For each item, provide its English name and a simple one-sentence definition. Return the result as a single JSON object that conforms to the provided schema.", image ]
+        
+        response = model.generate_content( prompt, generation_config={ "response_mime_type": "application/json", "response_schema": vocabulary_schema } )
+        json_response = json.loads(response.text)
+        return jsonify(json_response['vocabulary'])
+
+    except Exception as e:
+        print(f"Erro na análise de imagem: {e}")
+        return jsonify({"error": f"Image analysis failed: {e}"}), 500
+
+
+# --- ROTA 4: CHAT COM IA (NOVO - IDEAL PARA GROQ) ---
+@app.route('/chat-with-ai', methods=['POST'])
+def chat_with_ai():
+    if not groq_client:
+        return jsonify({"error": "GROQ_API_KEY not configured for the chat feature."}), 503
+        
+    data = request.get_json()
+    history = data.get('history', [])
+    user_message = data.get('message', '')
+    
+    if not user_message:
+        return jsonify({"error": "No message provided."}), 400
+
+    try:
+        # Instrução de sistema para o tutor de IA
+        system_instruction = "You are a friendly and encouraging English tutor named 'Groq Chat'. Your goal is to help the user practice their English conversation skills. Keep your responses concise (1-2 sentences). If the user makes a grammar mistake, gently correct it and explain briefly. Ask questions to keep the conversation flowing. Always respond in English."
+
+        # Monta o histórico de mensagens para a API
+        messages = [{"role": "system", "content": system_instruction}]
+        messages.extend(history)
+        messages.append({"role": "user", "content": user_message})
+        
+        # Chama a API da Groq
+        response = groq_client.chat.completions.create(
+            # Usando um modelo rápido, ideal para chat
+            model="llama-3.1-8b-instant",
+            messages=messages,
+            temperature=0.7
+        )
+        
+        ai_response = response.choices[0].message.content.strip()
+        return jsonify({"response": ai_response})
+
+    except Exception as e:
+        print(f"Erro no chat com IA: {e}")
+        return jsonify({"error": f"AI chat failed: {e}"}), 500
+
+
+# --- FUNÇÃO AUXILIAR PARA CHAMADAS DE IA (APENAS TEXTO) ---
+def get_ai_text_response(provider, model_name, system_instruction, user_prompt, json_schema=None):
+    # ... (código existente sem alterações) ...
+    if provider == 'gemini':
+        if not genai_client:
+            raise Exception("Gemini client not initialized.")
+        model = genai_client.GenerativeModel(model_name)
+        generation_config = {"response_mime_type": "application/json", "response_schema": json_schema} if json_schema else None
+        response = model.generate_content(user_prompt, generation_config=generation_config)
+        return json.loads(response.candidates[0].content.parts[0].text.strip()) if json_schema else response.text.strip()
+
+    elif provider == 'groq':
+        if not groq_client:
+            raise Exception("Groq client not initialized.")
+        messages = [{"role": "system", "content": system_instruction}, {"role": "user", "content": user_prompt}]
+        config_params = {'response_format': {"type": "json_object"}} if json_schema else {}
+        response = groq_client.chat.completions.create(model=model_name, messages=messages, **config_params)
+        text_response = response.choices[0].message.content.strip()
+        return json.loads(text_response) if json_schema else text_response
+            
+    else:
+        raise Exception(f"Unsupported provider: {provider}")
+
+
+# --- ROTA DE INICIALIZAÇÃO ---
 @app.route('/')
 def root():
     return send_file('index.html')