Update app.py

app.py

@@ -6,17 +6,99 @@ from datetime import datetime, timedelta
 import pandas as pd
 import random
 from typing import Dict, List, Optional
+from performance_system import PerformanceAnalyzer
+from simulado_system import SimuladoSystem, CasoClinicoSystem
+import json
 from database.db_manager import DatabaseManager
 from database.db_operations import adicionar_lote_questoes
-from study_generators import StudyPlanGenerator
-from performance_system import (
-    PerformanceAnalyzer, 
-    StudyMaterialGenerator, 
-    ProgressTracker,
-    initialize_performance_system
-)
+from study_generators import StudyMaterialGenerator, StudyPlanGenerator
+from performance_analyzer import PerformanceAnalyzer
+import json
+
+class CRMJABot:
+    def __init__(self):
+        self.db = DatabaseManager()
+        self.material_generator = StudyMaterialGenerator(self.db)
+        self.planner = StudyPlanGenerator(self.db)
+        self.performance = PerformanceAnalyzer(self.db.get_connection())  # Corrigido aqui
+        
+        try:
+            with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
+                questoes = json.load(f)
+            
+            sucesso, mensagem = adicionar_lote_questoes(self.db, questoes)
+            
+            if sucesso:
+                print("Questões adicionadas com sucesso!")
+            else:
+                print(f"Erro: {mensagem}")
+                
+        except Exception as e:
+            print(f"Erro na inicialização: {str(e)}")
+
+def create_interface():
+    return CRMJABot()
+
+if __name__ == "__main__":
+    interface = create_interface()
+def buscar_questoes_para_simulado(db: DatabaseManager, usuario_id: str, 
+                                 num_questoes: int = 10, 
+                                 areas: list = None,
+                                 dificuldade: str = None):
+    """Busca questões para gerar simulado personalizado"""
+    try:
+        conn = db.get_connection()
+        cursor = conn.cursor()
+        
+        # Busca áreas fracas do usuário
+        user_profile = db.get_user_profile(usuario_id)
+        weak_areas = user_profile.get('weak_areas', [])
+        
+        # Monta a query
+        query = '''
+        SELECT * FROM previous_questions 
+        WHERE 1=1
+        '''
+        params = []
+        
+        if areas:
+            query += ' AND area IN ({})'.format(','.join(['?']*len(areas)))
+            params.extend(areas)
+            
+        if dificuldade:
+            query += ' AND difficulty = ?'
+            params.append(dificuldade)
+            
+        # Prioriza áreas fracas
+        if weak_areas:
+            query += f''' 
+            ORDER BY 
+            CASE 
+                WHEN area IN ({','.join(['?']*len(weak_areas))}) THEN 1 
+                ELSE 2 
+            END, 
+            RANDOM()
+            '''
+            params.extend(weak_areas)
+        else:
+            query += ' ORDER BY RANDOM()'
+            
+        query += ' LIMIT ?'
+        params.append(num_questoes)
+        
+        cursor.execute(query, params)
+        questoes = cursor.fetchall()
+        
+        return [dict(q) for q in questoes]
+        
+    except Exception as e:
+        logger.error(f"Erro ao buscar questões: {e}")
+        return []
+from performance_system import PerformanceAnalyzer, StudyMaterialGenerator, ProgressTracker
 
 class MotivationalCoach:
+    """Classe para gerenciar mensagens e estratégias motivacionais"""
+    
     def __init__(self):
         self.frases_motivacionais = [
             "🌟 Cada hora de estudo te aproxima mais do seu objetivo!",
@@ -28,10 +110,11 @@ class MotivationalCoach:
             "🌅 Um novo dia, uma nova oportunidade de aprender!",
             "🎓 Sua aprovação no Revalida está cada vez mais próxima!"
         ]
+        
         self.dicas_estudo = [
             "📌 Faça pequenas pausas a cada 45 minutos de estudo",
             "💡 Revise o conteúdo do dia antes de dormir",
-            "🎯 Estabeleça metas diárias pequenas e alcançáveis", 
+            "🎯 Estabeleça metas diárias pequenas e alcançáveis",
             "📊 Alterne entre diferentes tópicos para manter o interesse",
             "🌟 Pratique questões antigas do Revalida regularmente",
             "💪 Mantenha uma rotina regular de estudos",
@@ -45,267 +128,308 @@ class MotivationalCoach:
     def get_study_tip(self) -> str:
         return random.choice(self.dicas_estudo)
 
-class AdminPanel:
-    def __init__(self, db: DatabaseManager):
-        self.db = db
-
-    def process_command(self, message: str, user_id: str) -> str:
-        if not self.db.is_admin(user_id):
-            return "Desculpe, apenas administradores têm acesso a este comando."
-
-        command = message.split(maxsplit=1)[1].strip() if len(message.split()) > 1 else ""
-
-        if command.startswith("adicionar_questao"):
-            try:
-                questao_data = json.loads(command.split(maxsplit=1)[1])
-                self.db.add_question(questao_data)
-                return "Questão adicionada com sucesso!"
-            except (json.JSONDecodeError, KeyError, IndexError):
-                return "Erro ao adicionar questão. Verifique o formato dos dados."
-        elif command.startswith("atualizar_questao"):
-            try:
-                questao_id, questao_data = command.split(maxsplit=2)[1:]
-                questao_data = json.loads(questao_data)
-                self.db.update_question(int(questao_id), questao_data)
-                return "Questão atualizada com sucesso!"
-            except (json.JSONDecodeError, KeyError, IndexError, ValueError):
-                return "Erro ao atualizar questão. Verifique o formato dos dados."
-        elif command.startswith("remover_questao"):
-            try:
-                questao_id = int(command.split(maxsplit=1)[1])
-                self.db.remove_question(questao_id)
-                return "Questão removida com sucesso!"
-            except (IndexError, ValueError):
-                return "Erro ao remover questão. Verifique o ID fornecido."
-        else:
-            return "Comando inválido. Comandos disponíveis: adicionar_questao, atualizar_questao, remover_questao."
+class StudyAnalytics:
+    """Classe para análise avançada do progresso do estudante"""
+    
+    def __init__(self, db_connection):
+        self.conn = db_connection
+
+    def calculate_study_metrics(self, user_id: str) -> Dict:
+        """Calcula métricas avançadas de estudo"""
+        cursor = self.conn.cursor()
+        
+        # Horas totais de estudo
+        cursor.execute('''
+            SELECT SUM(horas_estudadas) FROM study_progress 
+            WHERE user_id = ?
+        ''', (user_id,))
+        total_horas = cursor.fetchone()[0] or 0
+        
+        # Desempenho por área
+        cursor.execute('''
+            SELECT topic, AVG(performance_score) 
+            FROM study_progress 
+            WHERE user_id = ? 
+            GROUP BY topic
+        ''', (user_id,))
+        desempenho_por_area = dict(cursor.fetchall())
+        
+        # Consistência de estudos (dias consecutivos)
+        cursor.execute('''
+            SELECT date FROM study_progress 
+            WHERE user_id = ? 
+            ORDER BY date DESC
+        ''', (user_id,))
+        datas = [row[0] for row in cursor.fetchall()]
+        dias_consecutivos = self.calculate_streak(datas)
+        
+        return {
+            "total_horas": total_horas,
+            "desempenho_por_area": desempenho_por_area,
+            "dias_consecutivos": dias_consecutivos
+        }
+
+    @staticmethod
+    def calculate_streak(dates: List[str]) -> int:
+        if not dates:
+            return 0
+        
+        dates = [datetime.strptime(d, '%Y-%m-%d').date() for d in dates]
+        dates.sort(reverse=True)
+        
+        streak = 1
+        for i in range(len(dates)-1):
+            if (dates[i] - dates[i+1]).days == 1:
+                streak += 1
+            else:
+                break
+        return streak
 
 class CRMJABot:
+    """Assistente de estudos aprimorado para o Revalida"""
+    
     def __init__(self):
-        try:
-            self.db = DatabaseManager()
-        except Exception as e:
-            print(f"Erro ao inicializar o DatabaseManager: {e}")
-            return
-
-        try:
-            self.performance, self.material_generator, self.tracker = initialize_performance_system(
-                self.db.get_connection()
-            )
-        except Exception as e:
-            print(f"Erro ao inicializar o sistema de desempenho: {e}")
-            return
-        
+        self.db = DatabaseManager()
         self.planner = StudyPlanGenerator(self.db)
         self.coach = MotivationalCoach()
-        self.admin_panel = AdminPanel(self.db)
-        self.user_info = {}
-        
+        self.analytics = StudyAnalytics(self.db.conn)
+        self.performance = PerformanceAnalyzer(self.db.get_connection())  # Linha corrigida
+        self.material_gen = StudyMaterialGenerator(self.db.conn)
+        self.tracker = ProgressTracker(self.db.conn)
+
         try:
             self.qa_pipeline = pipeline(
                 "question-answering",
-                model="pierreguillou/bert-base-cased-squad-v1.1-portuguese", 
+                model="pierreguillou/bert-base-cased-squad-v1.1-portuguese",
                 device=-1
             )
         except Exception as e:
-            print(f"Erro ao carregar o modelo de perguntas e respostas: {e}")
+            print(f"Erro ao carregar o modelo: {e}")
             self.qa_pipeline = None
+        
+        self.commands = {
+            "/start": self.start_command,
+            "/plano": self.create_plan,
+            "/progresso": self.check_progress,
+            "/questoes": self.previous_questions,
+            "/estudo": self.study_mode,
+            "/dica": self.get_tip,
+            "/motiva": self.get_motivation,
+            "/resumo": self.get_summary,
+            "/ajuda": self.help_command,
+            "/simulado": self.start_simulado,
+            "/caso": self.start_caso_clinico,
+            "/bancoquestoes": self.banco_questoes,
+            "/revisao": self.modo_revisao,
+            "/meta": self.set_goal,
+            "/perfil": self.show_profile,
+            "/configurar": self.configure_preferences
+        }
+        
+    def start_command(self, message: str, user_id: str) -> str:
+        """Mensagem inicial de boas-vindas"""
+        return f"""🌟 Olá! Eu sou o crmjaBot, seu assistente pessoal para o Revalida!
+
+Estou aqui para te ajudar a alcançar seu objetivo de aprovação! Vamos juntos nessa jornada? 
 
+Comandos principais:
+📚 /plano - Criar plano de estudos personalizado
+📊 /progresso - Verificar seu progresso
+📝 /questoes - Praticar questões anteriores
+⏱ /estudo - Registrar sessão de estudo
+💡 /dica - Receber dica de estudo
+🌟 /motiva - Mensagem motivacional
+📋 /resumo - Resumo do seu desempenho
+❓ /ajuda - Ver todos os comandos
+
+{self.coach.get_motivational_message()}
+
+Como posso te ajudar hoje?"""
+
+    def get_tip(self, message: str, user_id: str) -> str:
+        """Fornece dica de estudo"""
+        return f"💡 Dica do dia:\n\n{self.coach.get_study_tip()}"
+
+    def get_motivation(self, message: str, user_id: str) -> str:
+        """Fornece mensagem motivacional"""
+        return f"✨ Mensagem motivacional:\n\n{self.coach.get_motivational_message()}"
+
+    def get_summary(self, message: str, user_id: str) -> str:
+        """Fornece resumo completo do progresso"""
         try:
-            with open('data/questoes_revalida.json', 'r', encoding='utf-8') as f:
-                questoes = json.load(f)
-            sucesso, mensagem = adicionar_lote_questoes(self.db, questoes)
-            print("Questões adicionadas com sucesso!" if sucesso else f"Erro: {mensagem}")
-        except Exception as e:
-            print(f"Erro ao carregar as questões do arquivo JSON: {str(e)}")
+            metrics = self.analytics.calculate_study_metrics(user_id)
+            
+            response = f"""📊 Resumo do seu desempenho:
+
+⏱ Total de horas estudadas: {metrics['total_horas']:.1f}h
+🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
 
-    def process_message(self, message, user_id, history):
-        if user_id not in self.user_info:
-            self.user_info[user_id] = {'name': None, 'email': None}
+📈 Desempenho por área:"""
             
-        if not self.user_info[user_id]['name']:
-            self.user_info[user_id]['name'] = message
-            return f"Prazer em conhecê-lo(a), {message}! Por favor, me informe também seu email para que eu possa personalizar melhor sua experiência."
-        elif not self.user_info[user_id]['email']:
-            self.user_info[user_id]['email'] = message  
-            self.db.add_user(user_id, self.user_info[user_id]['name'], self.user_info[user_id]['email'])
-            return f"Obrigado, {self.user_info[user_id]['name']}! Agora estou pronto para ajudá-lo(a) com sua preparação para o Revalida. O que você gostaria de fazer? Digite /help para ver as opções."
-                
-        if message.strip() == "":
-            return ""
-        
-        if message.startswith("/"):
-            command = message.split()[0]
-            if command == "/start":
-                return f"Bem-vindo de volta, {self.user_info[user_id]['name']}! Como posso ajudar hoje?"
-            elif command == "/help":
-                return """Comandos disponíveis:
-/start - Inicia o bot
-/help - Mostra os comandos disponíveis 
-/progresso - Verifica seu progresso
-/resumo - Mostra um resumo do seu desempenho
-/estudo - Registra uma sessão de estudo
-/lembretes - Configura lembretes de estudo
-/admin - Acessa o painel de administração (apenas para administradores)"""
-            elif command == "/progresso":
-                return self.check_progress(user_id)
-            elif command == "/resumo":
-                return self.get_summary(user_id)  
-            elif command == "/estudo":
-                return self.study_mode(message, user_id)
-            elif command == "/lembretes":
-                return self.set_reminders(message, user_id)
-            elif command == "/admin":  
-                return self.admin_panel.process_command(message, user_id)
-            else:
-                return "Comando inválido. Digite /help para ver os comandos disponíveis."
-        else:
-            return self.generate_response(message, user_id, history)
-
-    def generate_response(self, message, user_id, history):
-        if self.qa_pipeline:
-            try:
-                question = message
-                context = " ".join([msg[1] for msg in history[-5:]])
-                answer = self.qa_pipeline(question=question, context=context)
-                return answer['answer']
-            except Exception as e:
-                print(f"Erro ao gerar resposta: {e}")
-                return "Desculpe, não consegui entender sua pergunta. Poderia reformular?"
-        else:
-            return "Desculpe, ainda estou aprendendo a responder perguntas gerais. Por enquanto, posso ajudar com comandos específicos. Digite /help para ver o que sei fazer!"
+            for area, score in metrics['desempenho_por_area'].items():
+                response += f"\n- {area}: {score:.1f}%"
+            
+            response += f"\n\n{self.coach.get_motivational_message()}"
+            
+            return response
+            
+        except Exception as e:
+            return f"Erro ao gerar resumo: {str(e)}"
 
-    def check_progress(self, user_id):
+    def create_plan(self, message: str, user_id: str) -> str:
+        """Criar plano de estudos personalizado com elementos motivacionais"""
         try:
-            metrics = self.performance.get_performance_metrics(user_id)
-            streak_info = self.tracker.calculate_study_streak(user_id)
+            parts = message.split()
+            if len(parts) < 3:
+                return """📚 Para criar seu plano personalizado, preciso de algumas informações:
+
+Formato: /plano horas_diarias AAAA-MM-DD área1,área2
+
+Exemplo: /plano 4 2024-07-15 ClínicaMédica,Cirurgia
+
+As áreas disponíveis são:
+- ClínicaMédica
+- Cirurgia
+- Pediatria
+- GinecologiaObstetrícia
+- MedicinaFamília
+- SaúdeMental"""
+
+            horas = int(parts[1])
+            data_alvo = parts[2]
+            areas_fracas = parts[3].split(',') if len(parts) > 3 else []
             
-            response = f"""📊 Análise Detalhada do seu Progresso:
-⭐ Total de horas estudadas: {metrics['overall_metrics']['total_hours']:.1f}h
-🎯 Média de desempenho: {metrics['overall_metrics']['avg_performance']:.1f}%
-📅 Dias de estudo: {metrics['overall_metrics']['study_days']}
-🔥 Sequência atual: {streak_info['current_streak']} dias
-🏆 Maior sequência: {streak_info['longest_streak']} dias
-📈 Desempenho por área:"""
+            plano = self.planner.create_study_plan(user_id, horas, data_alvo, areas_fracas)
             
-            for topic, data in metrics['topic_metrics'].items():
-                avg_score = pd.Series(data['scores']).mean() if data['scores'] else 0
-                response += f"\n  ▪ {topic}: {avg_score:.1f}% ({data['total_hours']}h)"
+            response = f"""✨ Seu Plano de Estudos Personalizado está pronto! 
 
-            weak_topics = [topic for topic, data in metrics['topic_metrics'].items() 
-                         if pd.Series(data['scores']).mean() < 70]
+{self.coach.get_motivational_message()}
+
+📚 Distribuição semanal:"""
+
+            for semana, topicos in plano.items():
+                response += f"\n\n📅 {semana}:"
+                for topico, horas in topicos.items():
+                    response += f"\n  ▪ {topico}: {horas}h"
+
+            response += f"\n\n💡 Dica: {self.coach.get_study_tip()}"
             
-            if weak_topics:
-                response += "\n\n📚 Áreas que precisam de mais atenção:"
-                for topic in weak_topics:
-                    resources = self.material_generator.get_recommended_resources(
-                        topic, metrics['topic_metrics'][topic]
-                    )
-                    response += f"\n  ▪ {topic}:"
-                    for resource in resources[:2]:
-                        response += f"\n    - {resource}"
+            return response
+            
+        except Exception as e:
+            return f"Erro ao criar plano: {str(e)}"
+
+    def check_progress(self, message: str, user_id: str) -> str:
+        """Verifica o progresso com feedback motivacional"""
+        try:
+            metrics = self.analytics.calculate_study_metrics(user_id)
+            
+            response = f"""📊 Seu Progresso:
+
+⭐ Incrível! Você já estudou {metrics['total_horas']:.1f} horas no total!
+🎯 Sequência atual: {metrics['dias_consecutivos']} dias consecutivos
+
+📈 Desempenho por área:"""
+            
+            for area, score in metrics['desempenho_por_area'].items():
+                response += f"\n  ▪ {area}: {score:.1f}%"
 
             response += f"\n\n{self.coach.get_motivational_message()}"
             
+            if metrics['dias_consecutivos'] >= 7:
+                response += "\n\n🏆 Parabéns pela dedicação consistente!"
+            
             return response
             
         except Exception as e:
             return f"Erro ao verificar progresso: {str(e)}"
-                
-    def study_mode(self, message, user_id):
+
+    def study_mode(self, message: str, user_id: str) -> str:
+        """Registra sessão de estudo com feedback motivacional"""
         try:
             parts = message.split()
             if len(parts) < 3:
                 return """📚 Para registrar seu estudo:
-                
+
 Formato: /estudo área horas
+
 Exemplo: /estudo ClínicaMédica 2.5"""
-                
+            
             area = parts[1]
             horas = float(parts[2])
-
-            cursor = self.db.get_connection().cursor()
+            
+            cursor = self.db.conn.cursor()
             cursor.execute('''
-            INSERT INTO study_progress 
-            (user_id, date, topic, horas_estudadas, performance_score)
-            VALUES (?, ?, ?, ?, ?)
-            ''', (user_id, datetime.now().date(), area, horas, 0.0))
-            self.db.get_connection().commit()
-
-            metrics = self.performance.get_performance_metrics(user_id) 
-            streak_info = self.tracker.calculate_study_streak(user_id)
-
-            next_plan = self.material_generator.generate_daily_plan(
-                user_id, horas, metrics['topic_metrics']
-            )
-
+            INSERT INTO study_progress
+            (user_id, date, topic, horas_estudadas, questions_answered, performance_score)
+            VALUES (?, ?, ?, ?, ?, ?)
+            ''', (user_id, datetime.now().date(), area, horas, 0, 0.0))
+            self.db.conn.commit()
+            
+            metrics = self.analytics.calculate_study_metrics(user_id)
+            
             response = f"""✅ Ótimo trabalho! Registrei {horas}h de estudo em {area}
 
-📊 Status atual:
-⭐ Total de horas: {metrics['overall_metrics']['total_hours']:.1f}h  
-🔥 Sequência: {streak_info['current_streak']} dias
-🏆 Recorde: {streak_info['longest_streak']} dias
+⭐ Total de horas estudadas: {metrics['total_horas']:.1f}h
+🎯 Sequência atual: {metrics['dias_consecutivos']} dias
 
-📚 Sugestões para próxima sessão:"""
-
-            for area, horas in next_plan['distribuicao_horas'].items():
-                response += f"\n  ▪ {area}: {horas}h"
-
-            response += f"\n\n{self.coach.get_motivational_message()}"
-            response += f"\n\n💡 Dica: {self.coach.get_study_tip()}"
+{self.coach.get_motivational_message()}
 
+💡 Dica: {self.coach.get_study_tip()}"""
+            
             return response
-
+            
         except Exception as e:
             return f"Erro ao registrar estudo: {str(e)}"
 
-    def get_summary(self, user_id):
-        try:
-            metrics = self.performance.get_performance_metrics(user_id)
-            streak_info = self.tracker.calculate_study_streak(user_id)
-
-            response = f"""📊 Resumo Completo do seu Desempenho:
+    def generate_response(self, message: str, history: List) -> str:
+        """Gera resposta personalizada usando o pipeline de QA"""
+        if not self.qa_pipeline:
+            return f"""Desculpe, o modelo de linguagem não está disponível no momento.
 
-⏱ Métricas Gerais:
-▪ Total de horas estudadas: {metrics['overall_metrics']['total_hours']:.1f}h
-▪ Média de desempenho: {metrics['overall_metrics']['avg_performance']:.1f}%
-▪ Dias de estudo: {metrics['overall_metrics']['study_days']}  
-▪ Sequência atual: {streak_info['current_streak']} dias
-▪ Maior sequência: {streak_info['longest_streak']} dias
+{self.coach.get_motivational_message()}
 
-📈 Progresso por Área:"""
+Use /ajuda para ver os comandos disponíveis!"""
+            
+        try:
+            context = "\n".join([h[1] for h in history[-3:]] if history else "")
+            
+            result = self.qa_pipeline(
+                question=message,
+                context=context or "Você é o crmjaBot, um assistente motivacional e educacional para o Revalida."
+            )
+            
+            return f"""{result['answer']}
 
-            for topic, data in metrics['topic_metrics'].items():
-                avg_score = pd.Series(data['scores']).mean() if data['scores'] else 0
-                last_study = data['last_study']
-                response += f"\n\n📌 {topic}:"
-                response += f"\n  ▪ Desempenho: {avg_score:.1f}%"
-                response += f"\n  ▪ Horas dedicadas: {data['total_hours']}h"
-                response += f"\n  ▪ Último estudo: {last_study}"
+{self.coach.get_motivational_message()}"""
+        except Exception as e:
+            return f"Erro ao gerar resposta: {str(e)}"
 
-            response += f"\n\n{self.coach.get_motivational_message()}"
+    def help_command(self, message: str, user_id: str) -> str:
+        """Mostra todos os comandos disponíveis"""
+        return """🤖 Comandos do crmjaBot:
 
-            return response
+📚 Estudos:
+/plano - Criar plano de estudos personalizado
+/estudo - Registrar sessão de estudo
+/questoes - Praticar questões anteriores
 
-        except Exception as e:
-            return f"Erro ao gerar resumo: {str(e)}"
-
-    def set_reminders(self, message, user_id):
-        parts = message.split()
-        if len(parts) < 3:
-            return """📅 Para configurar lembretes de estudo:
-            
-Formato: /lembretes hora frequência
-Exemplo: /lembretes 20:00 diariamente"""
+📊 Acompanhamento:
+/progresso - Ver seu progresso
+/resumo - Resumo completo do desempenho
 
-        reminder_time = parts[1]
-        frequency = parts[2]
+✨ Motivacional:
+/dica - Receber dica de estudo
+/motiva - Mensagem motivacional
 
-        self.db.set_reminder(user_id, reminder_time, frequency)
+❓ Ajuda:
+/start - Iniciar/reiniciar bot
+/ajuda - Ver esta mensagem
 
-        return f"✅ Lembrete de estudo configurado com sucesso para as {reminder_time}, {frequency}!"
+Estou aqui para te ajudar! Como posso ser útil hoje?"""
 
 def create_interface():
+    """Criar interface Gradio"""
     bot = CRMJABot()
     
     with gr.Blocks(title="crmjaBot - Assistente Revalida") as interface:
@@ -327,9 +451,14 @@ def create_interface():
         clear = gr.ClearButton([msg, chatbot])
 
         def respond(message, history):
-            if message.strip() == "":
-                return "", history
-            
             bot_message = bot.process_message(message, user_id.value or "default_user", history)
             history.append((message, bot_message))
-            return "", history
+            return "", history
+
+        msg.submit(respond, [msg, chatbot], [msg, chatbot])
+
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()