app.py

import gradio as gr
from transformers import pipeline

def setup_models():
    print("Inicializando modelos...")
    
    # Modelo 1: Geração de perguntas sobre liderança
    question_model = pipeline(
        "text-generation",
        model="pierreguillou/gpt2-small-portuguese",
        max_length=100
    )
    
    # Modelo 2: Análise e reflexão sobre respostas
    reflection_model = pipeline(
        "text-generation",
        model="pierreguillou/gpt2-small-portuguese",
        max_length=200
    )
    
    return question_model, reflection_model

# Prompts para geração de diferentes tipos de perguntas sobre liderança
QUESTION_PROMPTS = [
    "Gere uma pergunta sobre como um líder deve gerenciar conflitos na equipe:",
    "Crie uma pergunta sobre como motivar equipes em momentos difíceis:",
    "Elabore uma pergunta sobre desenvolvimento de pessoas na liderança:",
    "Formule uma pergunta sobre tomada de decisão em situações críticas:",
    "Gere uma pergunta sobre comunicação efetiva na liderança:",
    "Crie uma pergunta sobre gestão de mudanças organizacionais:",
    "Elabore uma pergunta sobre feedback e avaliação de desempenho:",
    "Formule uma pergunta sobre delegação e empoderamento da equipe:"
]

class LeadershipMentor:
    def __init__(self, question_model, reflection_model):
        self.question_model = question_model
        self.reflection_model = reflection_model
        self.current_prompt_index = 0
        self.current_question = None
        
    def generate_question(self):
        """Gera uma nova pergunta usando o prompt atual"""
        if self.current_prompt_index < len(QUESTION_PROMPTS):
            prompt = QUESTION_PROMPTS[self.current_prompt_index]
            
            # Gerar pergunta usando o modelo
            response = self.question_model(prompt, max_length=100, num_return_sequences=1)
            question = response[0]['generated_text'].split(":")[-1].strip()
            
            # Garantir que a pergunta termine com ?
            if not question.endswith("?"):
                question += "?"
                
            self.current_question = question
            return question
        return None
    
    def generate_reflection(self, answer):
        """Gera uma reflexão sobre a resposta do usuário"""
        reflection_prompt = f"""
        Analise esta resposta de liderança e forneça uma reflexão construtiva:
        
        Pergunta: {self.current_question}
        Resposta: {answer}
        
        Considere:
        1. Pontos fortes demonstrados
        2. Áreas para desenvolvimento
        3. Sugestões práticas
        
        Reflexão:"""
        
        reflection = self.reflection_model(
            reflection_prompt, 
            max_length=200, 
            num_return_sequences=1
        )[0]['generated_text']
        
        return reflection.split("Reflexão:")[-1].strip()
    
    def process_interaction(self, answer, history):
        """Processa a interação do usuário e gera a próxima etapa"""
        if not answer:
            return "", history
            
        # Gerar reflexão sobre a resposta atual
        reflection = self.generate_reflection(answer)
        
        # Atualizar histórico
        new_history = history + [
            (self.current_question, answer),
            ("🤔 Reflexão:", reflection)
        ]
        
        # Avançar para próximo prompt
        self.current_prompt_index += 1
        
        # Gerar próxima pergunta se houver
        next_question = self.generate_question()
        if next_question:
            new_history.append(("📝 Próxima pergunta:", next_question))
        else:
            new_history.append(("✨ Sessão concluída!", "Obrigado por participar!"))
        
        return "", new_history

def create_interface():
    # Configurar modelos
    question_model, reflection_model = setup_models()
    mentor = LeadershipMentor(question_model, reflection_model)
    
    with gr.Blocks(title="Mentor de Liderança AI") as demo:
        gr.Markdown("""
        # 🎯 Mentor de Liderança AI
        
        Sistema interativo de desenvolvimento de liderança que:
        - Gera perguntas personalizadas sobre diferentes aspectos da liderança
        - Analisa suas respostas
        - Fornece reflexões construtivas para seu desenvolvimento
        """)
        
        chatbot = gr.Chatbot(
            height=600,
            label="Sessão de Mentoria"
        )
        
        msg = gr.Textbox(
            label="Sua Resposta",
            placeholder="Digite sua resposta aqui...",
            lines=3
        )
        
        with gr.Row():
            submit = gr.Button("Enviar Resposta")
            clear = gr.Button("Reiniciar Sessão")
        
        # Iniciar com primeira pergunta
        first_question = mentor.generate_question()
        chatbot.value = [("📝 Primeira pergunta:", first_question)]
        
        submit.click(
            mentor.process_interaction,
            inputs=[msg, chatbot],
            outputs=[msg, chatbot]
        )
        
        def reset_session():
            mentor.current_prompt_index = 0
            first_question = mentor.generate_question()
            return "", [(f"📝 Primeira pergunta:", first_question)]
        
        clear.click(
            reset_session,
            outputs=[msg, chatbot]
        )
    
    return demo

if __name__ == "__main__":
    print("Iniciando sistema de mentoria...")
    demo = create_interface()
    demo.launch(share=True)