app.py

import gradio as gr
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import json
import os

class RevalidaBot:
    def __init__(self):
        # Inicializa o modelo
        self.model_id = "meta-llama/Llama-2-7b-chat-hf"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_id)
        self.pipeline = pipeline(
            "text-generation",
            model=self.model_id,
            tokenizer=self.tokenizer,
            max_length=500
        )
        
        # Carrega a base de conhecimento
        self.knowledge = self.load_knowledge()
        
        # Define os comandos disponíveis
        self.commands = {
            "/start": self.start_command,
            "/estudo": self.study_mode,
            "/caso": self.clinical_case,
            "/questao": self.question_mode,
            "/ajuda": self.help_command
        }

    def load_knowledge(self):
        """Carrega base de conhecimento do Revalida"""
        try:
            if os.path.exists("knowledge_base.json"):
                with open("knowledge_base.json", "r", encoding="utf-8") as f:
                    return json.load(f)
            return {}
        except Exception as e:
            print(f"Erro ao carregar conhecimento: {e}")
            return {}

    def process_message(self, message, history):
        """Processa mensagens recebidas"""
        try:
            # Verifica se é um comando
            if message.startswith("/"):
                command = message.split()[0]
                if command in self.commands:
                    return self.commands[command](message)
                return "Comando não reconhecido. Use /ajuda para ver os comandos disponíveis."
            
            # Processa pergunta normal
            return self.generate_response(message, history)
            
        except Exception as e:
            return f"Desculpe, ocorreu um erro: {str(e)}"

    def generate_response(self, message, history):
        """Gera resposta para perguntas sobre o Revalida"""
        prompt = f"""
        Pergunta sobre Revalida: {message}
        
        Como assistente especializado em Revalida, forneça uma resposta:
        1. Objetiva e direta
        2. Baseada em evidências
        3. Focada no exame
        4. Com exemplos práticos quando relevante
        """
        
        response = self.pipeline(prompt, max_length=500)[0]['generated_text']
        return response

    # Comandos
    def start_command(self, _):
        return """🏥 Bem-vindo ao Assistente Revalida!

Comandos disponíveis:
/estudo - Modo estudo direcionado
/caso - Gerar caso clínico
/questao - Questão exemplo
/ajuda - Ver ajuda

Digite sua dúvida a qualquer momento!"""

    def study_mode(self, message):
        topic = message.replace("/estudo", "").strip()
        if not topic:
            return "Por favor, especifique o tópico após /estudo. Exemplo: /estudo clínica médica"
            
        prompt = f"Prepare um resumo focado para o Revalida sobre: {topic}"
        return self.generate_response(prompt, None)

    def clinical_case(self, _):
        prompt = "Gere um caso clínico objetivo para estudo do Revalida"
        return self.generate_response(prompt, None)

    def question_mode(self, _):
        prompt = "Crie uma questão de múltipla escolha no estilo Revalida"
        return self.generate_response(prompt, None)

    def help_command(self, _):
        return """📚 Comandos do Assistente Revalida:

/start - Iniciar/Reiniciar
/estudo [tópico] - Estudar um tópico específico
/caso - Gerar caso clínico para estudo
/questao - Gerar questão exemplo
/ajuda - Ver esta mensagem

💡 Dicas:
- Digite sua dúvida normalmente para perguntar
- Seja específico nas perguntas
- Use os comandos para funções especiais"""

def create_interface():
    """Cria a interface Gradio"""
    bot = RevalidaBot()
    
    with gr.Blocks(title="Assistente Revalida") as interface:
        gr.Markdown("# 🏥 Assistente Revalida")
        gr.Markdown("### Seu companheiro de estudos para o Revalida")
        
        chatbot = gr.Chatbot()
        msg = gr.Textbox(
            placeholder="Digite sua mensagem ou comando aqui...",
            show_label=False
        )
        clear = gr.ClearButton([msg, chatbot])

        msg.submit(
            bot.process_message, 
            [msg, chatbot], 
            [chatbot]
        )

    return interface

# Inicia a interface
if __name__ == "__main__":
    interface = create_interface()
    interface.launch()