Update app.py

app.py

@@ -1,64 +1,140 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+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__":
-    demo.launch()
+    interface = create_interface()
+    interface.launch()