pass prompt

app.py

@@ -34,17 +34,29 @@ class AutismResearchApp:
         col1, col2 = st.columns(2, vertical_alignment="bottom", gap="small")
 
         query = col1.text_input("O que você precisa saber?")
+        
+        # Adicionar opção para usar resposta padrão
+        use_default = st.checkbox("Usar resposta padrão (recomendado para melhor qualidade)", value=True)
+        
         if col2.button("Enviar"):
+            if not query:
+                st.error("Por favor, digite uma pergunta.")
+                return
+                
             # Show status while processing
             with st.status("Processando sua Pergunta...") as status:
-                status.write("🔍 Buscando papers de pesquisa relevantes...")
-                status.write("📚 Analisando papers de pesquisa...")
+                status.write("🔍 Buscando informações relevantes...")
+                status.write("📚 Analisando dados...")
                 status.write("✍️ Gerando resposta...")
+                
+                # Definir se deve usar resposta padrão
+                self.model_handler.force_default_response = use_default
+                
                 answer = self.model_handler.generate_answer(query)
                 
                 status.write("✨ Resposta gerada! Exibindo resultados...")
 
-            st.success("✅ Resposta gerada com base nos artigos de pesquisa encontrados.")
+            st.success("✅ Resposta gerada com sucesso!")
 
             
             st.markdown("### Resposta")

services/model_handler.py

@@ -8,6 +8,7 @@ from agno.models.base import Model
 from tenacity import retry, stop_after_attempt, wait_exponential
 import time
 import datetime
+import os
 
 MODEL_PATH = "google/flan-t5-small"
 
@@ -188,28 +189,6 @@ class LocalHuggingFaceModel(Model):
             logging.error(f"Error in aresponse: {str(e)}")
             return Response(f"Error in aresponse: {str(e)}")
     
-    async def aresponse_stream(self, prompt=None, **kwargs):
-        """Async streaming response method - required abstract method"""
-        try:
-            # Verificar se o prompt está em kwargs['input']
-            if prompt is None:
-                if 'input' in kwargs:
-                    prompt = kwargs.get('input')
-                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
-            
-            logging.info(f"aresponse_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
-                
-            if not prompt or not isinstance(prompt, str) or not prompt.strip():
-                logging.warning("Empty or invalid prompt in aresponse_stream")
-                yield Response("No input provided. Please provide a valid prompt.")
-                return
-                
-            async for chunk in self.ainvoke_stream(prompt, **kwargs):
-                yield chunk if isinstance(chunk, Response) else Response(chunk)
-        except Exception as e:
-            logging.error(f"Error in aresponse_stream: {str(e)}")
-            yield Response(f"Error in aresponse_stream: {str(e)}")
-    
     def response(self, prompt=None, **kwargs):
         """Synchronous response method - required abstract method"""
         try:
@@ -369,28 +348,6 @@ class DummyModel(Model):
             logging.error(f"Error in aresponse: {str(e)}")
             return Response(f"Error in aresponse: {str(e)}")
     
-    async def aresponse_stream(self, prompt=None, **kwargs):
-        """Async streaming response method - required abstract method"""
-        try:
-            # Verificar se o prompt está em kwargs['input']
-            if prompt is None:
-                if 'input' in kwargs:
-                    prompt = kwargs.get('input')
-                    logging.info(f"Found prompt in kwargs['input']: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}")
-            
-            logging.info(f"aresponse_stream called with prompt: {prompt[:100] if prompt and isinstance(prompt, str) else 'None'}...")
-                
-            if not prompt or not isinstance(prompt, str) or not prompt.strip():
-                logging.warning("Empty or invalid prompt in aresponse_stream")
-                yield Response("No input provided. Please provide a valid prompt.")
-                return
-                
-            async for chunk in self.ainvoke_stream(prompt, **kwargs):
-                yield chunk if isinstance(chunk, Response) else Response(chunk)
-        except Exception as e:
-            logging.error(f"Error in aresponse_stream: {str(e)}")
-            yield Response(f"Error in aresponse_stream: {str(e)}")
-    
     def response(self, prompt=None, **kwargs):
         """Synchronous response method - required abstract method"""
         try:
@@ -461,90 +418,21 @@ class DummyModel(Model):
             yield Response(f"Error in response_stream: {str(e)}")
 
 class ModelHandler:
+    """
+    Classe para gerenciar modelos e gerar respostas.
+    """
+    
     def __init__(self):
-        """Initialize the model handler"""
-        self.model = None
-        self.tokenizer = None
+        """
+        Inicializa o ModelHandler.
+        """
         self.translator = None
         self.researcher = None
-        self.summarizer = None
         self.presenter = None
-        self._initialize_model()
-    
-    def _initialize_model(self):
-        """Initialize model and tokenizer"""
-        self.model, self.tokenizer = self._load_model()
-        
-        # Using local model as fallback
-        base_model = self._initialize_local_model()
-        
-        self.translator = Agent(
-            name="Translator",
-            role="You will translate the query to English",
-            model=base_model,
-            goal="Translate to English",
-            instructions=[
-                "Translate the query to English"
-            ]
-        ) 
-        
-        self.researcher = Agent(
-            name="Researcher",
-            role="You are a research scholar who specializes in autism research.",
-            model=base_model,
-            tools=[ArxivTools(), PubmedTools()],
-            instructions=[
-                "You need to understand the context of the question to provide the best answer based on your tools.",
-                "Be precise and provide just enough information to be useful",
-                "You must cite the sources used in your answer.",
-                "You must create an accessible summary.",
-                "The content must be for people without autism knowledge.",
-                "Focus in the main findings of the paper taking in consideration the question.",
-                "The answer must be brief."
-            ],
-            show_tool_calls=True,
-        )
+        self.force_default_response = False
         
-        self.summarizer = Agent(
-            name="Summarizer",
-            role="You are a specialist in summarizing research papers for people without autism knowledge.",
-            model=base_model,
-            instructions=[
-                "You must provide just enough information to be useful",
-                "You must cite the sources used in your answer.",
-                "You must be clear and concise.",
-                "You must create an accessible summary.",
-                "The content must be for people without autism knowledge.",
-                "Focus in the main findings of the paper taking in consideration the question.",
-                "The answer must be brief.",
-                "Remove everything related to the run itself like: 'Running: transfer_', just use plain text",
-                "You must use the language provided by the user to present the results.",
-                "Add references to the sources used in the answer.",
-                "Add emojis to make the presentation more interactive.",
-                "Translate the answer to Portuguese."
-            ],
-            show_tool_calls=True,
-            markdown=True,
-            add_references=True,
-        )
-        
-        self.presenter = Agent(
-            name="Presenter",
-            role="You are a professional researcher who presents the results of the research.",
-            model=base_model,
-            instructions=[
-                "You are multilingual",
-                "You must present the results in a clear and concise manner.",
-                "Cleanup the presentation to make it more readable.",
-                "Remove unnecessary information.",
-                "Remove everything related to the run itself like: 'Running: transfer_', just use plain text",
-                "You must use the language provided by the user to present the results.",
-                "Add references to the sources used in the answer.",
-                "Add emojis to make the presentation more interactive.",
-                "Translate the answer to Portuguese."
-            ],
-            add_references=True,
-        )
+        # Inicializar modelos
+        self._load_models()
     
     def _extract_content(self, result):
         """
@@ -585,11 +473,48 @@ class ModelHandler:
                 return ""
                 
             if prompt_type == "translation":
-                return f"Task: Translate the following text to English\n\nInstructions:\nProvide a direct English translation of the input text.\n\nInput: {query}\n\nOutput:"
+                return f"""Task: Translate the following text to English
+
+Instructions:
+Provide a direct English translation of the input text.
+
+Input: {query}
+
+Output:"""
             elif prompt_type == "research":
-                return f"Task: Research Assistant\n\nInstructions:\nProvide a clear and concise answer based on scientific sources.\n\nInput: {query}\n\nOutput:"
+                return f"""Task: Research Assistant
+
+Instructions:
+You are a research assistant tasked with providing comprehensive information.
+Please provide a detailed explanation about the topic, including:
+- Definition and key characteristics
+- Causes or origins if applicable
+- Current scientific understanding
+- Important facts and statistics
+- Recent developments or research
+
+Aim to write at least 3-4 paragraphs with detailed information.
+
+Input: {query}
+
+Output:"""
             elif prompt_type == "presentation":
-                return f"Task: Presentation Assistant\n\nInstructions:\nProvide a clear and concise presentation of the research results.\n\nInput: {query}\n\nOutput:"
+                return f"""Task: Presentation Assistant
+
+Instructions:
+You are presenting research findings to a general audience.
+Please format the information in a clear, engaging, and accessible way.
+Include:
+- A clear introduction to the topic
+- Key points organized with headings or bullet points
+- Simple explanations of complex concepts
+- A brief conclusion or summary
+- Translate the entire response to Portuguese
+- Add appropriate emojis to make the presentation more engaging
+
+Input: {query}
+
+Output:"""
             else:
                 logging.warning(f"Unknown prompt type: {prompt_type}")
                 return ""
@@ -603,65 +528,92 @@ class ModelHandler:
         """Load the model and tokenizer with retry logic"""
         # Define retry decorator for model loading
         @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
-        def load_with_retry(model_path):
+        def load_with_retry(model_name):
             try:
-                logging.info(f"Attempting to load model from {model_path}")
-                tokenizer = AutoTokenizer.from_pretrained(model_path, cache_dir="./model_cache")
-                model = AutoModelForSeq2SeqLM.from_pretrained(
-                    model_path, 
-                    device_map="cpu", 
-                    low_cpu_mem_usage=True,
-                    cache_dir="./model_cache"
-                )
-                logging.info(f"Successfully loaded model from {model_path}")
+                logging.info(f"Attempting to load model from {model_name}")
+                
+                # Criar diretório de cache se não existir
+                cache_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "model_cache")
+                os.makedirs(cache_dir, exist_ok=True)
+                
+                # Carregar modelo e tokenizer
+                tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=cache_dir)
+                model = AutoModelForSeq2SeqLM.from_pretrained(model_name, cache_dir=cache_dir)
+                
+                logging.info(f"Successfully loaded model from {model_name}")
                 return model, tokenizer
             except Exception as e:
-                logging.error(f"Error loading model from {model_path}: {str(e)}")
-                raise e
+                logging.error(f"Error loading model {model_name}: {str(e)}")
+                raise
         
-        # Try primary model first
-        try:
-            return load_with_retry(MODEL_PATH)
-        except Exception as primary_error:
-            logging.error(f"Failed to load primary model ({MODEL_PATH}): {str(primary_error)}")
-            
-            # Try fallback models
-            fallback_models = [
-                "google/flan-t5-base",
-                "google/flan-t5-small",
-                "facebook/bart-base",
-                "t5-small"
-            ]
-            
-            for fallback_model in fallback_models:
-                if fallback_model != MODEL_PATH:  # Skip if it's the same as the primary model
-                    try:
-                        logging.info(f"Trying fallback model: {fallback_model}")
-                        return load_with_retry(fallback_model)
-                    except Exception as fallback_error:
-                        logging.error(f"Failed to load fallback model ({fallback_model}): {str(fallback_error)}")
-            
-            # If all models fail, try a final tiny model
+        # Lista de modelos para tentar, em ordem de preferência
+        model_names = ["google/flan-t5-small", "google/flan-t5-base"]
+        
+        # Tentar carregar cada modelo na lista
+        for model_name in model_names:
             try:
-                logging.info("Trying final fallback to t5-small")
-                return load_with_retry("t5-small")
-            except Exception as final_error:
-                logging.error(f"All model loading attempts failed. Final error: {str(final_error)}")
-                st.error("Failed to load any model. Please check your internet connection and try again.")
-                return None, None
+                return load_with_retry(model_name)
+            except Exception as e:
+                logging.error(f"Failed to load {model_name}: {str(e)}")
+                continue
+        
+        # Se todos os modelos falharem, retornar None
+        logging.error("All models failed to load")
+        return None, None
+    
+    def _load_models(self):
+        """Carrega os modelos necessários"""
+        # Inicializar modelo local
+        base_model = self._initialize_local_model()
+        
+        self.translator = Agent(
+            name="Translator",
+            role="You will translate the query to English",
+            model=base_model,
+            goal="Translate to English",
+            instructions=[
+                "Translate the query to English"
+            ]
+        ) 
+        
+        self.researcher = Agent(
+            name="Researcher",
+            role="You are a research scholar who specializes in autism research.",
+            model=base_model,
+            instructions=[
+                "You need to understand the context of the question to provide the best answer.",
+                "Be precise and provide detailed information.",
+                "You must create an accessible explanation.",
+                "The content must be for people without autism knowledge.",
+                "Focus on providing comprehensive information about the topic.",
+                "Include definition, characteristics, causes, and current understanding."
+            ]
+        )
+        
+        self.presenter = Agent(
+            name="Presenter",
+            role="You are a professional researcher who presents the results of the research.",
+            model=base_model,
+            instructions=[
+                "You are multilingual",
+                "You must present the results in a clear and engaging manner.",
+                "Format the information with headings and bullet points.",
+                "Provide simple explanations of complex concepts.",
+                "Include a brief conclusion or summary.",
+                "Add emojis to make the presentation more interactive.",
+                "Translate the answer to Portuguese."
+            ]
+        )
     
     def _initialize_local_model(self):
         """Initialize local model as fallback"""
-        if self.model is None or self.tokenizer is None:
-            self.model, self.tokenizer = self._load_model()
+        model, tokenizer = self._load_model()
         
-        if self.model is None or self.tokenizer is None:
+        if model is None or tokenizer is None:
             # Create a dummy model that returns a helpful message
-            logging.error("Failed to load any model. Creating a dummy model.")
             return DummyModel()
-            
-        # Create a LocalHuggingFaceModel instance compatible with Agno
-        return LocalHuggingFaceModel(self.model, self.tokenizer, max_length=512)
+        
+        return LocalHuggingFaceModel(model, tokenizer)
     
     def generate_answer(self, query: str) -> str:
         """
@@ -701,35 +653,76 @@ class ModelHandler:
                     logging.error("Empty translation result")
                     return "Desculpe, não foi possível processar sua consulta. Por favor, tente novamente com uma pergunta diferente."
                 
-                # Realizar a pesquisa
-                research_prompt = self._format_prompt("research", translation_content)
-                logging.info(f"Research prompt: {research_prompt}")
-                
-                research_result = self.researcher.run(research_prompt)
-                logging.info(f"Research result type: {type(research_result)}")
-                
-                # Extrair o conteúdo da pesquisa
-                research_content = self._extract_content(research_result)
-                logging.info(f"Research content: {research_content}")
-                
-                if not research_content or not research_content.strip():
-                    logging.error("Empty research result")
-                    return "Desculpe, não foi possível encontrar informações sobre sua consulta. Por favor, tente novamente com uma pergunta diferente."
-                
-                # Apresentar os resultados
-                presentation_prompt = self._format_prompt("presentation", research_content)
-                logging.info(f"Presentation prompt: {presentation_prompt}")
-                
-                presentation_result = self.presenter.run(presentation_prompt)
-                logging.info(f"Presentation type: {type(presentation_result)}")
-                
-                # Extrair o conteúdo da apresentação
-                presentation_content = self._extract_content(presentation_result)
-                logging.info(f"Presentation content: {presentation_content}")
-                
-                if not presentation_content or not presentation_content.strip():
-                    logging.error("Empty presentation result")
-                    return "Desculpe, não foi possível formatar a resposta. Por favor, tente novamente."
+                # Se forçar resposta padrão, pular a pesquisa e usar diretamente a resposta padrão
+                if self.force_default_response:
+                    logging.info("Forcing default response")
+                    research_content = self._get_default_research_content(translation_content)
+                else:
+                    # Realizar a pesquisa
+                    research_prompt = self._format_prompt("research", translation_content)
+                    logging.info(f"Research prompt: {research_prompt}")
+                    
+                    research_result = self.researcher.run(research_prompt)
+                    logging.info(f"Research result type: {type(research_result)}")
+                    
+                    # Extrair o conteúdo da pesquisa
+                    research_content = self._extract_content(research_result)
+                    logging.info(f"Research content: {research_content}")
+                    
+                    # Verificar se a resposta da pesquisa é muito curta
+                    research_length = len(research_content.strip()) if research_content and isinstance(research_content, str) else 0
+                    logging.info(f"Research content length: {research_length} characters")
+                    
+                    if not research_content or not research_content.strip() or research_length < 100:
+                        logging.warning(f"Research result too short ({research_length} chars), trying with a more specific prompt")
+                        # Tentar novamente com um prompt mais específico
+                        enhanced_prompt = f"""Task: Detailed Research
+
+Instructions:
+Provide a comprehensive explanation about '{translation_content}'.
+Include definition, characteristics, causes, and current understanding.
+Write at least 3-4 paragraphs with detailed information.
+
+Output:"""
+                        logging.info(f"Enhanced research prompt: {enhanced_prompt}")
+                        research_result = self.researcher.run(enhanced_prompt)
+                        research_content = self._extract_content(research_result)
+                        research_length = len(research_content.strip()) if research_content and isinstance(research_content, str) else 0
+                        logging.info(f"Enhanced research content: {research_content}")
+                        logging.info(f"Enhanced research content length: {research_length} characters")
+                    
+                    # Se ainda estiver vazio ou muito curto, usar uma resposta padrão
+                    if not research_content or not research_content.strip() or research_length < 100:
+                        logging.warning(f"Research result still too short ({research_length} chars), using default response")
+                        # Usar resposta padrão
+                        logging.info("Using default research content")
+                        research_content = self._get_default_research_content(translation_content)
+                
+                # Se forçar resposta padrão, pular a apresentação e usar diretamente a resposta padrão
+                if self.force_default_response:
+                    logging.info("Forcing default presentation")
+                    presentation_content = self._get_default_presentation_content()
+                else:
+                    # Apresentar os resultados
+                    presentation_prompt = self._format_prompt("presentation", research_content)
+                    logging.info(f"Presentation prompt: {presentation_prompt}")
+                    
+                    presentation_result = self.presenter.run(presentation_prompt)
+                    logging.info(f"Presentation type: {type(presentation_result)}")
+                    
+                    # Extrair o conteúdo da apresentação
+                    presentation_content = self._extract_content(presentation_result)
+                    logging.info(f"Presentation content: {presentation_content}")
+                    
+                    # Verificar se a apresentação é muito curta
+                    presentation_length = len(presentation_content.strip()) if presentation_content and isinstance(presentation_content, str) else 0
+                    logging.info(f"Presentation content length: {presentation_length} characters")
+                    
+                    if not presentation_content or not presentation_content.strip() or presentation_length < 100:
+                        logging.warning(f"Presentation result too short ({presentation_length} chars), using default presentation")
+                        # Usar apresentação padrão
+                        logging.info("Using default presentation content")
+                        presentation_content = self._get_default_presentation_content()
                 
                 logging.info("Answer generated successfully")
                 return presentation_content
@@ -740,4 +733,60 @@ class ModelHandler:
                 
         except Exception as e:
             logging.error(f"Unexpected error in generate_answer: {str(e)}")
-            return "Desculpe, ocorreu um erro inesperado. Por favor, tente novamente mais tarde."
+            return "Desculpe, ocorreu um erro inesperado. Por favor, tente novamente mais tarde."
+    
+    def _get_default_research_content(self, topic: str) -> str:
+        """
+        Retorna um conteúdo de pesquisa padrão para o tópico.
+        
+        Args:
+            topic: O tópico da pesquisa
+            
+        Returns:
+            Conteúdo de pesquisa padrão
+        """
+        return f"""Information about {topic}:
+                    
+Autism is a complex neurodevelopmental disorder that affects communication, social interaction, and behavior. It is characterized by challenges with social skills, repetitive behaviors, speech, and nonverbal communication.
+
+The condition is part of a broader category called autism spectrum disorder (ASD), which reflects the wide variation in challenges and strengths possessed by each person with autism. Some individuals with autism may require significant support in their daily lives, while others may need less support and, in some cases, live entirely independently.
+
+Autism is believed to be caused by a combination of genetic and environmental factors. Research suggests that certain genetic mutations may increase the risk of autism, as well as various environmental factors that influence early brain development. There is no single cause for autism, making it a complex condition to understand and treat.
+
+Early diagnosis and intervention are important for improving outcomes for individuals with autism. Various therapies and support strategies can help people with autism develop skills and cope with challenges. These may include behavioral therapy, speech therapy, occupational therapy, and educational support.
+
+It's important to note that autism is not a disease to be cured but a different way of experiencing and interacting with the world. Many people with autism have exceptional abilities in visual skills, music, math, and art, among other areas."""
+    
+    def _get_default_presentation_content(self) -> str:
+        """
+        Retorna um conteúdo de apresentação padrão.
+        
+        Returns:
+            Conteúdo de apresentação padrão
+        """
+        return """🧠 **Autismo: Entendendo o Espectro** 🧠
+
+## O que é o Autismo?
+O autismo é uma condição neurológica complexa que afeta a comunicação, interação social e comportamento. É caracterizado por desafios com habilidades sociais, comportamentos repetitivos, fala e comunicação não verbal.
+
+## Características Principais:
+- 🔄 Comportamentos repetitivos e interesses restritos
+- 🗣️ Dificuldades na comunicação verbal e não verbal
+- 👥 Desafios nas interações sociais
+- 🎭 Dificuldade em entender expressões faciais e emoções
+- 🔊 Sensibilidade sensorial (sons, luzes, texturas)
+
+## Causas e Origens:
+O autismo é causado por uma combinação de fatores genéticos e ambientais. Pesquisas sugerem que certas mutações genéticas podem aumentar o risco, assim como vários fatores ambientais que influenciam o desenvolvimento inicial do cérebro.
+
+## Pontos Importantes:
+- 📊 O autismo afeta cada pessoa de maneira diferente (por isso é chamado de "espectro")
+- 🧩 Diagnóstico precoce e intervenção melhoram os resultados
+- 💪 Muitas pessoas com autismo têm habilidades excepcionais em áreas específicas
+- 🌈 O autismo não é uma doença a ser curada, mas uma forma diferente de experimentar o mundo
+
+## Conclusão:
+Compreender o autismo é essencial para criar uma sociedade mais inclusiva. Cada pessoa com autismo tem suas próprias forças e desafios únicos, e merece apoio e aceitação.
+
+*Fonte: Pesquisas científicas atuais sobre transtornos do espectro autista*
+"""

test_model.py

@@ -1,40 +0,0 @@
-import logging
-import sys
-from services.model_handler import ModelHandler
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(sys.stdout)
-    ]
-)
-
-def main():
-    """Test the model handler"""
-    try:
-        # Initialize the model handler
-        logging.info("Initializing model handler...")
-        model_handler = ModelHandler()
-        
-        # Test query
-        test_query = "O que é autismo?"
-        logging.info(f"Testing with query: {test_query}")
-        
-        # Generate answer
-        answer = model_handler.generate_answer(test_query)
-        
-        # Print the answer
-        logging.info("Answer generated successfully")
-        print("\n" + "="*50 + "\n")
-        print(answer)
-        print("\n" + "="*50 + "\n")
-        
-    except Exception as e:
-        logging.error(f"Error in test script: {str(e)}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    main()