def store_interaction(self, agent_id, prompt, response, domain=None, feedback=None, tags=None):
    """
    Armazena uma interação entre um agente e um usuário na base de conhecimento.
    
    Args:
        agent_id (str): Identificador único do agente
        prompt (str): Prompt enviado ao agente
        response (str): Resposta gerada pelo agente
        domain (str, optional): Domínio ou área de conhecimento da interação
        feedback (str, optional): Feedback do usuário (1-5 ou texto)
        tags (list, optional): Lista de tags para categorização
        
    Returns:
        str: ID da interação armazenada
    """
    try:
        # Validar parâmetros obrigatórios
        if not agent_id or not prompt or not response:
            raise ValueError("Agent ID, prompt e response são campos obrigatórios")
            
        # Preparar metadados
        metadata = {
            "timestamp": datetime.now().isoformat(),
            "agent_id": agent_id,
            "domain": domain or "general",
            "tags": tags or [],
            "feedback_score": None,
            "feedback_text": None
        }
        
        # Processar feedback (numérico ou textual)
        if feedback:
            try:
                # Tentar converter para número (escala 1-5)
                score = float(feedback)
                if 1 <= score <= 5:
                    metadata["feedback_score"] = score
                else:
                    metadata["feedback_text"] = feedback
            except ValueError:
                # Se não for número, armazenar como texto
                metadata["feedback_text"] = feedback
        
        # Criar documento de interação
        interaction = {
            "prompt": prompt,
            "response": response,
            "metadata": metadata
        }
        
        # Armazenar no banco de dados
        interaction_id = self.knowledge_base.insert_interaction(interaction)
        
        # Analisar a interação para identificar padrões
        self._analyze_interaction(interaction_id, interaction)
        
        # Registrar log de sucesso
        logger.info(f"Interaction stored successfully: {interaction_id}")
        
        return interaction_id
        
    except Exception as e:
        # Registrar erro e propagar exceção
        logger.error(f"Error storing interaction: {str(e)}")
        raise
        
def _analyze_interaction(self, interaction_id, interaction):
    """
    Analisa uma interação para identificar padrões e insights.
    
    Args:
        interaction_id (str): ID da interação
        interaction (dict): Dados da interação
    """
    # Extrair texto do prompt e resposta
    prompt_text = interaction["prompt"]
    response_text = interaction["response"]
    domain = interaction["metadata"]["domain"]
    
    # Análise básica de texto
    prompt_tokens = self.nlp_processor.tokenize(prompt_text)
    prompt_entities = self.nlp_processor.extract_entities(prompt_text)
    prompt_keywords = self.nlp_processor.extract_keywords(prompt_text)
    
    # Armazenar resultados da análise
    analysis_results = {
        "token_count": len(prompt_tokens),
        "entities": prompt_entities,
        "keywords": prompt_keywords,
        "complexity_score": self.nlp_processor.calculate_complexity(prompt_text),
        "domain_relevance": self.domain_analyzer.calculate_relevance(prompt_text, domain)
    }
    
    # Atualizar a interação com os resultados da análise
    self.knowledge_base.update_interaction_analysis(interaction_id, analysis_results)
    
    # Agendar análise mais profunda em lote
    self.analysis_queue.add_task(interaction_id)
    
def get_domain_interactions(self, domain, limit=100, min_feedback_score=None):
    """
    Recupera interações de um domínio específico, opcionalmente filtradas por pontuação de feedback.
    
    Args:
        domain (str): Domínio ou área de conhecimento
        limit (int, optional): Número máximo de interações a retornar
        min_feedback_score (float, optional): Pontuação mínima de feedback (1-5)
        
    Returns:
        list: Lista de interações que atendem aos critérios
    """
    query = {"metadata.domain": domain}
    
    if min_feedback_score is not None:
        query["metadata.feedback_score"] = {"$gte": min_feedback_score}
    
    interactions = self.knowledge_base.find_interactions(query, limit=limit)
    
    return interactions