Create app.py

app.py

@@ -0,0 +1,416 @@
+import os
+import json
+import gradio as gr
+import google.generativeai as genai
+from typing import Dict, List, Optional
+
+# ==================== CONFIGURAÇÃO DA API GEMINI ====================
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY", "SUA_API_KEY_AQUI"))
+counselor_model = genai.GenerativeModel("gemini-flash-latest")
+supervisor_model = genai.GenerativeModel("gemini-flash-latest")
+
+# ==================== HISTÓRICOS GLOBAIS ====================
+historico_dialogo: List[Dict] = []
+historico_passo1_clareza: List[Dict] = []
+historico_passo2_proposito: List[Dict] = []
+historico_passo3_motivacao: List[Dict] = []
+historico_passo4_ambiguidade: List[Dict] = []
+
+# ==================== CARREGAMENTO DO CONTEXTO FILOSÓFICO ====================
+def carregar_contexto_filosofico(caminho_arquivo: str = "epct0.md") -> Optional[str]:
+    """Carrega o arquivo de contexto filosófico (Epicteto) se disponível."""
+    try:
+        with open(caminho_arquivo, "r", encoding="utf-8") as f:
+            print(f"✓ Contexto filosófico '{caminho_arquivo}' carregado com sucesso.")
+            return f.read()
+    except FileNotFoundError:
+        print(f"⚠ AVISO: Arquivo '{caminho_arquivo}' não encontrado. Modo Sábio ficará limitado.")
+        return None
+
+CONTEXTO_FILOSOFICO = carregar_contexto_filosofico()
+
+# ==================== PROMPTS PARA CADA PASSO ====================
+
+def prompt_passo1_clareza(historico_dialogo: List[Dict], historico_passo1: List[Dict], input_usuario: str) -> str:
+    """Prompt para análise de CLAREZA: Eu entendi o que o usuário quer?"""
+    return f"""
+Você é um analisador de CLAREZA em uma pipeline de raciocínio multi-etapa.
+
+Sua única tarefa: avaliar se você entendeu claramente o que o usuário está perguntando ou expressando.
+
+HISTÓRICO DE DIÁLOGO (perguntas e respostas anteriores):
+{json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
+
+HISTÓRICO DO PASSO 1 (suas análises anteriores de clareza):
+{json.dumps(historico_passo1, indent=2, ensure_ascii=False)}
+
+NOVO INPUT DO USUÁRIO:
+"{input_usuario}"
+
+INSTRUÇÕES:
+1. Se este é o primeiro turno ou se o usuário mudou completamente de assunto, analise a clareza do novo input isoladamente.
+2. Se o usuário está respondendo a uma pergunta sua anterior, reavalie: a clareza aumentou? Ele esclareceu o que você precisava?
+3. Se o input é ambíguo, vago ou tem múltiplas interpretações possíveis, classifique como confiança "baixa".
+4. Se você entendeu perfeitamente, classifique como "alta".
+
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+{{
+  "analise": "Sua análise textual sobre a clareza do input",
+  "confianca": "baixa|media|alta",
+  "decisao": "prosseguir|pedir_esclarecimento",
+  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta natural. Caso contrário, null."
+}}
+"""
+
+def prompt_passo2_proposito(historico_dialogo: List[Dict], historico_passo2: List[Dict], analise_p1: Dict) -> str:
+    """Prompt para análise de PROPÓSITO: Para que o usuário quer saber isso?"""
+    return f"""
+Você é um analisador de PROPÓSITO em uma pipeline de raciocínio multi-etapa.
+
+Sua única tarefa: identificar PARA QUE o usuário está fazendo essa pergunta ou expressando essa ideia.
+
+HISTÓRICO DE DIÁLOGO:
+{json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
+
+HISTÓRICO DO PASSO 2 (suas análises anteriores de propósito):
+{json.dumps(historico_passo2, indent=2, ensure_ascii=False)}
+
+ANÁLISE DE CLAREZA (PASSO 1):
+{json.dumps(analise_p1, indent=2, ensure_ascii=False)}
+
+INSTRUÇÕES:
+1. Com base no histórico e na análise de clareza, tente inferir o propósito do usuário.
+2. Exemplos de propósito: "tomar uma decisão", "aprender algo novo", "validar uma crença", "resolver um problema prático", "desabafar".
+3. Se você tem alta confiança sobre o propósito, classifique como "alta".
+4. Se não consegue determinar com certeza, classifique como "baixa" ou "media" e considere pedir esclarecimento.
+
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+{{
+  "analise": "Sua análise textual sobre o propósito",
+  "proposito_inferido": "Descrição do propósito ou null se incerto",
+  "confianca": "baixa|media|alta",
+  "decisao": "prosseguir|pedir_esclarecimento",
+  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta natural. Caso contrário, null."
+}}
+"""
+
+def prompt_passo3_motivacao(historico_dialogo: List[Dict], historico_passo3: List[Dict], analise_p2: Dict) -> str:
+    """Prompt para análise de MOTIVAÇÃO: Por que isso é importante para o usuário agora?"""
+    return f"""
+Você é um analisador de MOTIVAÇÃO em uma pipeline de raciocínio multi-etapa.
+
+Sua única tarefa: identificar POR QUE o usuário está interessado nisso agora. O que despertou essa necessidade?
+
+HISTÓRICO DE DIÁLOGO:
+{json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
+
+HISTÓRICO DO PASSO 3 (suas análises anteriores de motivação):
+{json.dumps(historico_passo3, indent=2, ensure_ascii=False)}
+
+ANÁLISE DE PROPÓSITO (PASSO 2):
+{json.dumps(analise_p2, indent=2, ensure_ascii=False)}
+
+INSTRUÇÕES:
+1. Tente identificar o gatilho emocional, contextual ou situacional que levou o usuário a fazer essa pergunta.
+2. Exemplos de motivação: "frustração com situação atual", "curiosidade intelectual", "urgência de decisão", "busca por validação", "experiência recente".
+3. Se você tem alta confiança sobre a motivação, classifique como "alta".
+4. Se não consegue determinar, classifique como "baixa" ou "media" e considere pedir esclarecimento.
+
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+{{
+  "analise": "Sua análise textual sobre a motivação",
+  "motivacao_inferida": "Descrição da motivação ou null se incerto",
+  "confianca": "baixa|media|alta",
+  "decisao": "prosseguir|pedir_esclarecimento",
+  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta natural. Caso contrário, null."
+}}
+"""
+
+def prompt_passo4_ambiguidade(historico_dialogo: List[Dict], historico_passo4: List[Dict], analise_p3: Dict) -> str:
+    """Prompt para análise de AMBIGUIDADE: Existem múltiplos cenários válidos que precisam ser desambiguados?"""
+    return f"""
+Você é um analisador de AMBIGUIDADE DE CENÁRIO em uma pipeline de raciocínio multi-etapa.
+
+Sua única tarefa: detectar se a pergunta/situação do usuário tem múltiplas interpretações ou cenários válidos que precisam ser esclarecidos antes de dar uma resposta final.
+
+HISTÓRICO DE DIÁLOGO:
+{json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
+
+HISTÓRICO DO PASSO 4 (suas análises anteriores de ambiguidade):
+{json.dumps(historico_passo4, indent=2, ensure_ascii=False)}
+
+ANÁLISE DE MOTIVAÇÃO (PASSO 3):
+{json.dumps(analise_p3, indent=2, ensure_ascii=False)}
+
+INSTRUÇÕES:
+1. Analise se a resposta pode variar significativamente dependendo de uma perspectiva, contexto ou premissa não explicitada.
+2. Exemplos de ambiguidade:
+   - "Me fale sobre carros" → pode ser engenharia, história, compra, manutenção, esportes...
+   - "Como lidar com ansiedade?" → pode ser clínica, filosófica, técnicas práticas, contexto profissional...
+3. Se há UMA ÚNICA resposta clara e direta possível, classifique confiança como "alta" e decisao "prosseguir_resposta_final".
+4. Se há múltiplos cenários válidos, classifique confiança como "baixa" e decisao "pedir_esclarecimento".
+
+RETORNE APENAS UM JSON VÁLIDO NO FORMATO:
+{{
+  "analise": "Sua análise textual sobre possíveis ambiguidades",
+  "cenarios_possiveis": ["cenário 1", "cenário 2", ...] ou null se não há ambiguidade,
+  "confianca": "baixa|media|alta",
+  "decisao": "prosseguir_resposta_final|pedir_esclarecimento",
+  "pergunta_esclarecimento": "Se decisao == pedir_esclarecimento, coloque aqui uma pergunta aberta e natural. Caso contrário, null."
+}}
+"""
+
+def prompt_sintetizador(historico_dialogo: List[Dict], analises: Dict, modo_sabio: bool) -> str:
+    """Prompt para SÍNTESE FINAL: gera a resposta textual ao usuário."""
+    contexto_filosofico_str = ""
+    if modo_sabio and CONTEXTO_FILOSOFICO:
+        contexto_filosofico_str = f"""
+--- CONTEXTO FILOSÓFICO (Epicteto) PARA SUA REFLEXÃO INTERNA ---
+{CONTEXTO_FILOSOFICO}
+
+IMPORTANTE: Use este contexto como sua bússola interna. NÃO cite Epicteto explicitamente. 
+Sua resposta deve soar como um amigo sábio, não como um professor de filosofia.
+Seja conversacional, empático, use humor leve quando apropriado, e empodere o usuário a encontrar suas próprias respostas.
+"""
+    
+    return f"""
+Você é um SINTETIZADOR FINAL de uma pipeline de análise conversacional.
+
+Sua tarefa: gerar uma resposta textual natural, completa e útil ao usuário, baseada em toda a análise acumulada.
+
+HISTÓRICO DE DIÁLOGO COMPLETO:
+{json.dumps(historico_dialogo, indent=2, ensure_ascii=False)}
+
+ANÁLISES CONSOLIDADAS DA PIPELINE:
+{json.dumps(analises, indent=2, ensure_ascii=False)}
+
+{contexto_filosofico_str}
+
+INSTRUÇÕES:
+1. Se algum dos passos indicou "pedir_esclarecimento", RETORNE APENAS A PERGUNTA DE ESCLARECIMENTO (do passo com menor confiança).
+2. Se todos os passos indicaram "prosseguir" ou "prosseguir_resposta_final", gere uma resposta completa e bem fundamentada.
+3. {"Se Modo Sábio estiver ativo, aplique a persona de Amigo Sábio conforme o contexto filosófico acima." if modo_sabio else "Use tom informativo e objetivo."}
+4. Sua resposta deve ser APENAS o texto final para o usuário. NÃO retorne JSON aqui.
+
+RESPOSTA FINAL:
+"""
+
+# ==================== FUNÇÃO AUXILIAR: CHAMADA AO GEMINI ====================
+def chamada_gemini(model, prompt: str) -> str:
+    """Faz chamada à API Gemini e retorna texto de resposta."""
+    try:
+        response = model.generate_content(prompt)
+        return response.text.strip()
+    except Exception as e:
+        print(f"❌ Erro ao chamar API Gemini: {e}")
+        return '{"erro": "Falha na comunicação com o modelo."}'
+
+# ==================== FUNÇÃO AUXILIAR: PARSE SEGURO DE JSON ====================
+def parse_json_seguro(texto: str) -> Dict:
+    """Tenta extrair JSON de resposta do LLM, mesmo se vier com markdown ou ruído."""
+    try:
+        # Remove possíveis blocos markdown ``````
+        texto = texto.replace("``````", "").strip()
+        return json.loads(texto)
+    except json.JSONDecodeError as e:
+        print(f"⚠ Erro ao parsear JSON: {e}")
+        print(f"Texto recebido: {texto}")
+        return {"erro": "Resposta inválida do modelo", "texto_original": texto}
+
+# ==================== PIPELINE PRINCIPAL ====================
+def processar_turno(mensagem_usuario: str, modo_sabio: bool = False, modo_supervisor: bool = True) -> str:
+    """
+    Processa um turno completo do usuário através da pipeline fragmentada.
+    Retorna a resposta textual final para exibição.
+    """
+    global historico_dialogo, historico_passo1_clareza, historico_passo2_proposito
+    global historico_passo3_motivacao, historico_passo4_ambiguidade
+
+    # 1. Registrar input do usuário no histórico de diálogo
+    historico_dialogo.append({"user": mensagem_usuario, "assistant": None})
+    
+    print("\n" + "="*70)
+    print(f"📩 NOVO INPUT DO USUÁRIO: {mensagem_usuario}")
+    print("="*70)
+
+    # 2. PASSO 1: Análise de CLAREZA
+    print("\n🔍 PASSO 1: Analisando CLAREZA...")
+    prompt1 = prompt_passo1_clareza(historico_dialogo[:-1], historico_passo1_clareza, mensagem_usuario)
+    resposta_p1 = chamada_gemini(counselor_model, prompt1)
+    analise_p1 = parse_json_seguro(resposta_p1)
+    historico_passo1_clareza.append(analise_p1)
+    print(f"   Confiança: {analise_p1.get('confianca', 'N/A')}")
+    print(f"   Decisão: {analise_p1.get('decisao', 'N/A')}")
+
+    # 3. PASSO 2: Análise de PROPÓSITO
+    print("\n🎯 PASSO 2: Analisando PROPÓSITO...")
+    prompt2 = prompt_passo2_proposito(historico_dialogo[:-1], historico_passo2_proposito, analise_p1)
+    resposta_p2 = chamada_gemini(counselor_model, prompt2)
+    analise_p2 = parse_json_seguro(resposta_p2)
+    historico_passo2_proposito.append(analise_p2)
+    print(f"   Confiança: {analise_p2.get('confianca', 'N/A')}")
+    print(f"   Decisão: {analise_p2.get('decisao', 'N/A')}")
+
+    # 4. PASSO 3: Análise de MOTIVAÇÃO
+    print("\n💡 PASSO 3: Analisando MOTIVAÇÃO...")
+    prompt3 = prompt_passo3_motivacao(historico_dialogo[:-1], historico_passo3_motivacao, analise_p2)
+    resposta_p3 = chamada_gemini(counselor_model, prompt3)
+    analise_p3 = parse_json_seguro(resposta_p3)
+    historico_passo3_motivacao.append(analise_p3)
+    print(f"   Confiança: {analise_p3.get('confianca', 'N/A')}")
+    print(f"   Decisão: {analise_p3.get('decisao', 'N/A')}")
+
+    # 5. PASSO 4: Análise de AMBIGUIDADE
+    print("\n🔀 PASSO 4: Analisando AMBIGUIDADE...")
+    prompt4 = prompt_passo4_ambiguidade(historico_dialogo[:-1], historico_passo4_ambiguidade, analise_p3)
+    resposta_p4 = chamada_gemini(counselor_model, prompt4)
+    analise_p4 = parse_json_seguro(resposta_p4)
+    historico_passo4_ambiguidade.append(analise_p4)
+    print(f"   Confiança: {analise_p4.get('confianca', 'N/A')}")
+    print(f"   Decisão: {analise_p4.get('decisao', 'N/A')}")
+
+    # 6. SÍNTESE FINAL
+    print("\n✨ SINTETIZANDO RESPOSTA FINAL...")
+    analises_consolidadas = {
+        "clareza": analise_p1,
+        "proposito": analise_p2,
+        "motivacao": analise_p3,
+        "ambiguidade": analise_p4
+    }
+    
+    prompt_final = prompt_sintetizador(historico_dialogo[:-1], analises_consolidadas, modo_sabio)
+    resposta_final = chamada_gemini(counselor_model, prompt_final)
+    
+    # 7. SUPERVISÃO (se ativada)
+    if modo_supervisor and analise_p4.get('decisao') == 'prosseguir_resposta_final':
+        print("\n🔍 MODO SUPERVISOR: Verificando fatos...")
+        feedback_supervisor = verificar_fatos(resposta_final)
+        
+        if feedback_supervisor:
+            print("   ⚠ Divergências encontradas. Iniciando autocorreção...")
+            resposta_final = autocorrigir(resposta_final, feedback_supervisor)
+    
+    # 8. Atualizar histórico de diálogo
+    historico_dialogo[-1]["assistant"] = resposta_final
+    
+    print("\n✅ RESPOSTA ENVIADA AO USUÁRIO")
+    print("="*70 + "\n")
+    
+    return resposta_final
+
+# ==================== FUNÇÕES DE SUPERVISÃO ====================
+def verificar_fatos(texto: str) -> Optional[str]:
+    """Verifica fatos no texto usando o modelo Supervisor."""
+    prompt_supervisor = f"""
+Você é um Supervisor de IA, um fact-checker rigoroso e objetivo.
+
+Sua única tarefa: analisar o texto abaixo em busca de INCORREÇÕES FACTUAIS.
+
+- Analise apenas FATOS verificáveis (datas, nomes, estatísticas, conceitos científicos).
+- NÃO analise opiniões, conselhos filosóficos ou estrutura da resposta.
+- Se encontrar divergências factuais com confiança média ou alta, liste-as claramente.
+- Se NÃO encontrar nenhuma divergência factual, responda APENAS: "NODIVERGENCE"
+
+TEXTO PARA ANÁLISE:
+{texto}
+
+SUA RESPOSTA:
+"""
+    try:
+        resposta = supervisor_model.generate_content(prompt_supervisor)
+        if "NODIVERGENCE" in resposta.text:
+            print("   ✓ Nenhuma divergência factual encontrada.")
+            return None
+        else:
+            print(f"   ⚠ Divergências: {resposta.text[:200]}...")
+            return resposta.text
+    except Exception as e:
+        print(f"❌ Erro no Supervisor: {e}")
+        return None
+
+def autocorrigir(resposta_original: str, feedback: str) -> str:
+    """Solicita autocorreção ao modelo Conselheiro."""
+    prompt_correcao = f"""
+Você é um Conselheiro em processo de refinamento.
+
+Sua resposta anterior continha uma imprecisão factual identificada pelo Supervisor.
+
+SUA RESPOSTA ORIGINAL:
+{resposta_original}
+
+FEEDBACK DO SUPERVISOR (CORREÇÃO):
+{feedback}
+
+SUA TAREFA:
+1. Aceite a correção sem ser defensivo.
+2. Reescreva sua resposta integrando a correção de forma natural.
+3. Ao final, adicione uma breve "Nota de Refinamento:" explicando a correção.
+
+RESPOSTA CORRIGIDA:
+"""
+    try:
+        resposta_corrigida = counselor_model.generate_content(prompt_correcao)
+        return resposta_corrigida.text
+    except Exception as e:
+        print(f"❌ Erro na autocorreção: {e}")
+        return resposta_original
+
+# ==================== FUNÇÃO PARA LIMPAR HISTÓRICOS ====================
+def resetar_conversa():
+    """Reseta todos os históricos para iniciar nova conversa."""
+    global historico_dialogo, historico_passo1_clareza, historico_passo2_proposito
+    global historico_passo3_motivacao, historico_passo4_ambiguidade
+    
+    historico_dialogo = []
+    historico_passo1_clareza = []
+    historico_passo2_proposito = []
+    historico_passo3_motivacao = []
+    historico_passo4_ambiguidade = []
+    
+    print("\n🔄 Históricos resetados. Nova conversa iniciada.\n")
+
+# ==================== WRAPPER PARA GRADIO ====================
+def handle_chat(mensagem: str, historico_chat_gradio: List, modo_sabio: bool, modo_supervisor: bool):
+    """Wrapper para integração com Gradio ChatInterface."""
+    
+    # Se é nova conversa (histórico vazio), reseta estados internos
+    if not historico_chat_gradio:
+        resetar_conversa()
+    
+    # Processa turno
+    resposta = processar_turno(mensagem, modo_sabio, modo_supervisor)
+    
+    return resposta
+
+# ==================== INTERFACE GRADIO ====================
+iface = gr.ChatInterface(
+    fn=handle_chat,
+    title="🧠 Parceiro de Raciocínio v10 — Pipeline Fragmentada",
+    description="""
+    Sistema de conversação com análise multi-etapa e memória granular.
+    
+    **Modo Amigo Sábio**: Reflexões filosóficas baseadas em Epicteto (requer epct0.md)
+    **Modo Supervisor**: Verificação automática de fatos e autocorreção
+    """,
+    chatbot=gr.Chatbot(height=600, label="Diálogo"),
+    textbox=gr.Textbox(placeholder="O que está na sua cabeça?", container=False, scale=7),
+    additional_inputs=[
+        gr.Checkbox(label="🧘 Ativar Modo Amigo Sábio (Filosofia)", value=False),
+        gr.Checkbox(label="🔍 Ativar Modo Supervisor (Fact-checking)", value=True)
+    ],
+    theme="soft",
+    examples=[
+        "Estou confuso sobre qual carreira seguir.",
+        "O Monte Everest tem mais de 9.000 metros de altura?",
+        "Por que sinto ansiedade antes de apresentações?",
+        "Me fale sobre inteligência artificial."
+    ],
+    cache_examples=False
+)
+
+# ==================== EXECUÇÃO ====================
+if __name__ == "__main__":
+    print("\n" + "="*70)
+    print("🚀 Iniciando Parceiro de Raciocínio v10 - Pipeline Fragmentada")
+    print("="*70 + "\n")
+    iface.launch()