top of page
Buscar

Template N8N - Framework MIA (Mapear - Isolar - Automatizar)

Homem de camisa branca com padrão escreve em quadro branco sobre "Workflow Strategy" e fluxograma de emails. Ambiente de escritório.

Vou criar um template completo do N8N baseado no framework MIA para automação de processos. Este template servirá como base para implementar qualquer processo seguindo a metodologia MIA.


Visão Geral do Template

O template está estruturado em três fases principais, cada uma com seus respectivos nós e configurações:


FASE 1: MAPEAR 

  • Objetivo: Identificar e documentar o processo atual

  • Componentes: Coleta de dados, análise de fluxo, identificação de gargalos


FASE 2: ISOLAR 

  • Objetivo: Separar e priorizar componentes para automação

  • Componentes: Filtros, condicionais, separação de fluxos


FASE 3: AUTOMATIZAR

  • Objetivo: Implementar a automação dos processos isolados

  • Componentes: Execução, monitoramento, feedback


Estrutura do Workflow N8N

Configuração Inicial

{
  "name": "Template MIA Framework",
  "nodes": [
    {
      "parameters": {},
      "name": "🚀 INÍCIO - Framework MIA",
      "type": "n8n-nodes-base.start",
      "typeVersion": 1,
      "position": [240, 300]
    }
  ]
}

FASE 1: MAPEAR 

1.1 Coleta de Dados Iniciais

{
  "parameters": {
    "functionCode": "// MAPEAMENTO - Coleta de dados do processo\nconst processData = {\n  processName: $json.processName || 'Processo não identificado',\n  startTime: new Date().toISOString(),\n  inputData: $json,\n  processSteps: [],\n  stakeholders: [],\n  currentBottlenecks: [],\n  estimatedTime: null,\n  priority: 'medium'\n};\n\n// Log inicial do mapeamento\nconsole.log('🗺️ MAPEAR - Iniciando análise do processo:', processData.processName);\n\nreturn {\n  json: {\n    phase: 'MAPEAR',\n    step: 'data_collection',\n    processData: processData,\n    timestamp: new Date().toISOString()\n  }\n};"
  },
  "name": "📊 Coleta de Dados",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [440, 200]
}

1.2 Análise de Fluxo Atual

{
  "parameters": {
    "functionCode": "// MAPEAMENTO - Análise detalhada do fluxo\nconst inputData = $json.processData;\n\n// Identificar etapas do processo\nconst processSteps = [\n  {\n    stepId: 1,\n    name: 'Recebimento de Input',\n    type: 'manual',\n    estimatedTime: '5min',\n    complexity: 'low',\n    automationPotential: 'high'\n  },\n  {\n    stepId: 2,\n    name: 'Validação de Dados',\n    type: 'manual',\n    estimatedTime: '10min',\n    complexity: 'medium',\n    automationPotential: 'high'\n  },\n  {\n    stepId: 3,\n    name: 'Processamento',\n    type: 'mixed',\n    estimatedTime: '30min',\n    complexity: 'high',\n    automationPotential: 'medium'\n  },\n  {\n    stepId: 4,\n    name: 'Entrega de Output',\n    type: 'manual',\n    estimatedTime: '5min',\n    complexity: 'low',\n    automationPotential: 'high'\n  }\n];\n\n// Calcular métricas do processo\nconst totalEstimatedTime = processSteps.reduce((total, step) => {\n  const time = parseInt(step.estimatedTime);\n  return total + time;\n}, 0);\n\nconst automationScore = processSteps.reduce((score, step) => {\n  const potential = step.automationPotential === 'high' ? 3 : \n                   step.automationPotential === 'medium' ? 2 : 1;\n  return score + potential;\n}, 0) / processSteps.length;\n\nconsole.log('📈 MAPEAR - Análise concluída. Score de automação:', automationScore);\n\nreturn {\n  json: {\n    ...inputData,\n    processSteps: processSteps,\n    metrics: {\n      totalSteps: processSteps.length,\n      totalEstimatedTime: totalEstimatedTime,\n      automationScore: automationScore,\n      manualSteps: processSteps.filter(s => s.type === 'manual').length\n    },\n    step: 'flow_analysis'\n  }\n};"
  },
  "name": "🔍 Análise de Fluxo",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [640, 200]
}

1.3 Identificação de Gargalos

{
  "parameters": {
    "functionCode": "// MAPEAMENTO - Identificação de gargalos e oportunidades\nconst processData = $json;\n\n// Identificar gargalos baseado na análise\nconst bottlenecks = processData.processSteps\n  .filter(step => step.complexity === 'high' || step.estimatedTime > '15min')\n  .map(step => ({\n    stepId: step.stepId,\n    name: step.name,\n    issue: step.complexity === 'high' ? 'Alta complexidade' : 'Tempo excessivo',\n    impact: 'high',\n    automationRecommendation: step.automationPotential\n  }));\n\n// Priorizar oportunidades de automação\nconst automationOpportunities = processData.processSteps\n  .filter(step => step.automationPotential === 'high')\n  .sort((a, b) => {\n    const complexityScore = { low: 1, medium: 2, high: 3 };\n    return complexityScore[a.complexity] - complexityScore[b.complexity];\n  });\n\n// Gerar relatório de mapeamento\nconst mappingReport = {\n  processName: processData.processData?.processName || 'Processo Mapeado',\n  totalSteps: processData.processSteps.length,\n  bottlenecksFound: bottlenecks.length,\n  automationOpportunities: automationOpportunities.length,\n  recommendedPriority: automationOpportunities.length > 2 ? 'high' : 'medium',\n  readyForIsolation: bottlenecks.length > 0 || automationOpportunities.length > 0\n};\n\nconsole.log('🎯 MAPEAR - Gargalos identificados:', bottlenecks.length);\nconsole.log('✅ MAPEAR - Fase concluída. Pronto para ISOLAR.');\n\nreturn {\n  json: {\n    phase: 'MAPEAR_COMPLETE',\n    mappingReport: mappingReport,\n    bottlenecks: bottlenecks,\n    automationOpportunities: automationOpportunities,\n    processData: processData,\n    nextPhase: 'ISOLAR',\n    timestamp: new Date().toISOString()\n  }\n};"
  },
  "name": "🚨 Identificar Gargalos",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [840, 200]
}

FASE 2: ISOLAR 

2.1 Filtro de Priorização

{
  "parameters": {
    "conditions": {
      "string": [
        {
          "value1": "={{$json.mappingReport.readyForIsolation}}",
          "operation": "equal",
          "value2": "true"
        }
      ]
    }
  },
  "name": "✅ Verificar Elegibilidade",
  "type": "n8n-nodes-base.if",
  "typeVersion": 1,
  "position": [1040, 200]
}

2.2 Separação por Complexidade

{
  "parameters": {
    "functionCode": "// ISOLAMENTO - Separar processos por complexidade e prioridade\nconst inputData = $json;\n\n// Separar oportunidades por critérios\nconst isolationCriteria = {\n  quickWins: [], // Baixa complexidade, alto impacto\n  mediumTasks: [], // Média complexidade\n  complexTasks: [], // Alta complexidade, requer análise detalhada\n  notRecommended: [] // Não recomendado para automação\n};\n\ninputData.automationOpportunities.forEach(opportunity => {\n  const complexity = opportunity.complexity;\n  const automationPotential = opportunity.automationPotential;\n  \n  if (complexity === 'low' && automationPotential === 'high') {\n    isolationCriteria.quickWins.push({\n      ...opportunity,\n      priority: 1,\n      estimatedROI: 'high',\n      implementationTime: 'short'\n    });\n  } else if (complexity === 'medium' && automationPotential === 'high') {\n    isolationCriteria.mediumTasks.push({\n      ...opportunity,\n      priority: 2,\n      estimatedROI: 'medium',\n      implementationTime: 'medium'\n    });\n  } else if (complexity === 'high') {\n    isolationCriteria.complexTasks.push({\n      ...opportunity,\n      priority: 3,\n      estimatedROI: 'variable',\n      implementationTime: 'long'\n    });\n  } else {\n    isolationCriteria.notRecommended.push({\n      ...opportunity,\n      priority: 4,\n      reason: 'Baixo potencial de automação'\n    });\n  }\n});\n\n// Definir sequência de implementação\nconst implementationSequence = [\n  ...isolationCriteria.quickWins,\n  ...isolationCriteria.mediumTasks,\n  ...isolationCriteria.complexTasks\n].sort((a, b) => a.priority - b.priority);\n\nconsole.log('🎯 ISOLAR - Tarefas categorizadas:');\nconsole.log('- Quick Wins:', isolationCriteria.quickWins.length);\nconsole.log('- Tarefas Médias:', isolationCriteria.mediumTasks.length);\nconsole.log('- Tarefas Complexas:', isolationCriteria.complexTasks.length);\n\nreturn {\n  json: {\n    phase: 'ISOLAR',\n    step: 'categorization',\n    isolationCriteria: isolationCriteria,\n    implementationSequence: implementationSequence,\n    recommendedStart: implementationSequence[0] || null,\n    totalIsolatedTasks: implementationSequence.length,\n    originalData: inputData\n  }\n};"
  },
  "name": "📋 Categorizar Tarefas",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [1240, 120]
}

2.3 Seleção para Automação

{
  "parameters": {
    "functionCode": "// ISOLAMENTO - Selecionar primeira tarefa para automação\nconst isolationData = $json;\n\n// Selecionar a tarefa de maior prioridade\nconst selectedTask = isolationData.recommendedStart;\n\nif (!selectedTask) {\n  console.log('❌ ISOLAR - Nenhuma tarefa elegível para automação');\n  return {\n    json: {\n      phase: 'ISOLAR_FAILED',\n      reason: 'Nenhuma tarefa elegível encontrada',\n      recommendation: 'Revisar processo de mapeamento'\n    }\n  };\n}\n\n// Preparar dados para automação\nconst automationPlan = {\n  taskId: selectedTask.stepId,\n  taskName: selectedTask.name,\n  priority: selectedTask.priority,\n  estimatedTime: selectedTask.estimatedTime,\n  complexity: selectedTask.complexity,\n  automationType: determineAutomationType(selectedTask),\n  requiredTools: determineRequiredTools(selectedTask),\n  successCriteria: defineSuccessCriteria(selectedTask),\n  rollbackPlan: defineRollbackPlan(selectedTask)\n};\n\nfunction determineAutomationType(task) {\n  if (task.name.includes('Validação')) return 'validation';\n  if (task.name.includes('Processamento')) return 'processing';\n  if (task.name.includes('Entrega')) return 'delivery';\n  return 'generic';\n}\n\nfunction determineRequiredTools(task) {\n  const tools = ['HTTP Request'];\n  if (task.complexity !== 'low') tools.push('Function');\n  if (task.name.includes('Dados')) tools.push('Set');\n  return tools;\n}\n\nfunction defineSuccessCriteria(task) {\n  return {\n    executionTime: `< ${task.estimatedTime}`,\n    errorRate: '< 5%',\n    dataIntegrity: '100%',\n    userSatisfaction: '> 80%'\n  };\n}\n\nfunction defineRollbackPlan(task) {\n  return {\n    triggerConditions: ['Error rate > 10%', 'Execution time > 2x expected'],\n    rollbackSteps: ['Stop automation', 'Notify stakeholders', 'Revert to manual process'],\n    recoveryTime: '< 30min'\n  };\n}\n\nconsole.log('🎯 ISOLAR - Tarefa selecionada para automação:', selectedTask.name);\nconsole.log('✅ ISOLAR - Fase concluída. Pronto para AUTOMATIZAR.');\n\nreturn {\n  json: {\n    phase: 'ISOLAR_COMPLETE',\n    selectedTask: selectedTask,\n    automationPlan: automationPlan,\n    remainingTasks: isolationData.implementationSequence.slice(1),\n    nextPhase: 'AUTOMATIZAR',\n    isolationData: isolationData\n  }\n};"
  },
  "name": "🎯 Selecionar para Automação",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [1440, 120]
}

FASE 3: AUTOMATIZAR 

3.1 Configuração da Automação

{
  "parameters": {
    "functionCode": "// AUTOMATIZAÇÃO - Configurar ambiente de execução\nconst planData = $json;\nconst automationPlan = planData.automationPlan;\n\n// Configurar parâmetros de execução\nconst executionConfig = {\n  taskId: automationPlan.taskId,\n  taskName: automationPlan.taskName,\n  startTime: new Date().toISOString(),\n  maxRetries: 3,\n  timeoutMinutes: parseInt(automationPlan.estimatedTime) * 2,\n  monitoringEnabled: true,\n  loggingLevel: 'detailed',\n  notificationChannels: ['email', 'webhook']\n};\n\n// Preparar dados de entrada para o processo automatizado\nconst processInput = {\n  originalData: planData.isolationData.originalData,\n  taskSpecificData: {\n    stepId: automationPlan.taskId,\n    expectedOutput: determineExpectedOutput(automationPlan.automationType),\n    validationRules: defineValidationRules(automationPlan.automationType)\n  },\n  executionContext: {\n    environment: 'production',\n    version: '1.0.0',\n    executedBy: 'n8n-automation',\n    correlationId: generateCorrelationId()\n  }\n};\n\nfunction determineExpectedOutput(type) {\n  switch(type) {\n    case 'validation': return { status: 'validated', errors: [] };\n    case 'processing': return { status: 'processed', result: {} };\n    case 'delivery': return { status: 'delivered', confirmation: true };\n    default: return { status: 'completed' };\n  }\n}\n\nfunction defineValidationRules(type) {\n  const baseRules = ['required_fields_present', 'data_format_valid'];\n  switch(type) {\n    case 'validation': return [...baseRules, 'business_rules_applied'];\n    case 'processing': return [...baseRules, 'processing_logic_valid'];\n    case 'delivery': return [...baseRules, 'delivery_format_correct'];\n    default: return baseRules;\n  }\n}\n\nfunction generateCorrelationId() {\n  return 'auto_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);\n}\n\nconsole.log('⚡ AUTOMATIZAR - Configuração preparada para:', automationPlan.taskName);\nconsole.log('🔧 AUTOMATIZAR - Correlation ID:', processInput.executionContext.correlationId);\n\nreturn {\n  json: {\n    phase: 'AUTOMATIZAR',\n    step: 'configuration',\n    executionConfig: executionConfig,\n    processInput: processInput,\n    automationPlan: automationPlan,\n    status: 'ready_for_execution'\n  }\n};"
  },
  "name": "⚙️ Configurar Automação",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [1640, 120]
}

3.2 Execução da Automação

{
  "parameters": {
    "functionCode": "// AUTOMATIZAÇÃO - Executar processo automatizado\nconst configData = $json;\nconst processInput = configData.processInput;\nconst executionConfig = configData.executionConfig;\n\n// Simular execução do processo automatizado\nconst executionStart = new Date();\nconst correlationId = processInput.executionContext.correlationId;\n\ntry {\n  console.log('🚀 AUTOMATIZAR - Iniciando execução:', correlationId);\n  \n  // Simular processamento baseado no tipo de automação\n  const automationType = configData.automationPlan.automationType;\n  let executionResult;\n  \n  switch(automationType) {\n    case 'validation':\n      executionResult = executeValidation(processInput);\n      break;\n    case 'processing':\n      executionResult = executeProcessing(processInput);\n      break;\n    case 'delivery':\n      executionResult = executeDelivery(processInput);\n      break;\n    default:\n      executionResult = executeGeneric(processInput);\n  }\n  \n  const executionEnd = new Date();\n  const executionTime = executionEnd - executionStart;\n  \n  // Validar critérios de sucesso\n  const successValidation = validateSuccess(\n    executionResult, \n    executionTime, \n    configData.automationPlan.successCriteria\n  );\n  \n  console.log('✅ AUTOMATIZAR - Execução concluída em:', executionTime + 'ms');\n  console.log('📊 AUTOMATIZAR - Status:', successValidation.status);\n  \n  return {\n    json: {\n      phase: 'AUTOMATIZAR',\n      step: 'execution_complete',\n      correlationId: correlationId,\n      executionResult: executionResult,\n      executionMetrics: {\n        startTime: executionStart.toISOString(),\n        endTime: executionEnd.toISOString(),\n        duration: executionTime,\n        status: successValidation.status,\n        successCriteriaMet: successValidation.criteriaMet\n      },\n      originalConfig: configData\n    }\n  };\n  \n} catch (error) {\n  console.error('❌ AUTOMATIZAR - Erro na execução:', error.message);\n  \n  return {\n    json: {\n      phase: 'AUTOMATIZAR_ERROR',\n      correlationId: correlationId,\n      error: {\n        message: error.message,\n        timestamp: new Date().toISOString(),\n        requiresRollback: true\n      },\n      originalConfig: configData\n    }\n  };\n}\n\nfunction executeValidation(input) {\n  // Simular validação de dados\n  return {\n    status: 'validated',\n    validatedFields: ['field1', 'field2', 'field3'],\n    errors: [],\n    warnings: [],\n    confidence: 0.95\n  };\n}\n\nfunction executeProcessing(input) {\n  // Simular processamento de dados\n  return {\n    status: 'processed',\n    inputRecords: 100,\n    processedRecords: 98,\n    failedRecords: 2,\n    result: {\n      summary: 'Processamento concluído com sucesso',\n      details: 'Dados processados conforme regras de negócio'\n    }\n  };\n}\n\nfunction executeDelivery(input) {\n  // Simular entrega de resultados\n  return {\n    status: 'delivered',\n    deliveryMethod: 'api',\n    deliveryTime: new Date().toISOString(),\n    confirmation: true,\n    recipients: ['system_a', 'system_b']\n  };\n}\n\nfunction executeGeneric(input) {\n  // Execução genérica\n  return {\n    status: 'completed',\n    message: 'Processo executado com sucesso',\n    data: input.taskSpecificData\n  };\n}\n\nfunction validateSuccess(result, executionTime, criteria) {\n  const criteriaMet = {\n    executionTime: executionTime < (parseInt(criteria.executionTime) * 60000),\n    errorRate: (result.failedRecords || 0) / (result.inputRecords || 1) < 0.05,\n    dataIntegrity: result.status !== 'failed',\n    overallSuccess: result.status === 'validated' || result.status === 'processed' || result.status === 'delivered' || result.status === 'completed'\n  };\n  \n  const allCriteriaMet = Object.values(criteriaMet).every(met => met === true);\n  \n  return {\n    status: allCriteriaMet ? 'success' : 'partial_success',\n    criteriaMet: criteriaMet\n  };\n}"
  },
  "name": "🚀 Executar Processo",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [1840, 120]
}

3.3 Monitoramento e Feedback

{
  "parameters": {
    "functionCode": "// AUTOMATIZAÇÃO - Monitoramento e geração de relatório final\nconst executionData = $json;\n\n// Gerar relatório completo do Framework MIA\nconst miaReport = {\n  frameworkVersion: '1.0.0',\n  executionId: executionData.correlationId,\n  timestamp: new Date().toISOString(),\n  \n  // Resumo das fases\n  phasesSummary: {\n    mapear: {\n      status: 'completed',\n      tasksIdentified: executionData.originalConfig?.automationPlan ? 1 : 0,\n      bottlenecksFound: 'N/A', // Seria obtido dos dados anteriores\n      duration: 'N/A'\n    },\n    isolar: {\n      status: 'completed',\n      tasksIsolated: 1,\n      priorityLevel: executionData.originalConfig?.automationPlan?.priority || 'unknown',\n      selectedForAutomation: executionData.originalConfig?.automationPlan?.taskName || 'unknown'\n    },\n    automatizar: {\n      status: executionData.executionMetrics?.status || 'unknown',\n      executionTime: executionData.executionMetrics?.duration || 0,\n      successRate: calculateSuccessRate(executionData.executionResult),\n      criteriaMet: executionData.executionMetrics?.successCriteriaMet || {}\n    }\n  },\n  \n  // Métricas de performance\n  performanceMetrics: {\n    totalExecutionTime: executionData.executionMetrics?.duration || 0,\n    automationEfficiency: calculateEfficiency(executionData),\n    errorRate: calculateErrorRate(executionData.executionResult),\n    roi: calculateROI(executionData),\n    timesSaved: calculateTimeSaved(executionData)\n  },\n  \n  // Recomendações para próximas iterações\n  recommendations: generateRecommendations(executionData),\n  \n  // Status final\n  overallStatus: determineOverallStatus(executionData),\n  nextSteps: generateNextSteps(executionData)\n};\n\nfunction calculateSuccessRate(result) {\n  if (!result) return 0;\n  if (result.status === 'validated' || result.status === 'processed' || \n      result.status === 'delivered' || result.status === 'completed') {\n    return result.failedRecords ? \n      ((result.processedRecords || 1) / (result.inputRecords || 1)) * 100 : 100;\n  }\n  return 0;\n}\n\nfunction calculateEfficiency(data) {\n  const executionTime = data.executionMetrics?.duration || 0;\n  const expectedTime = 300000; // 5 minutos em ms (estimativa)\n  return Math.max(0, ((expectedTime - executionTime) / expectedTime) * 100);\n}\n\nfunction calculateErrorRate(result) {\n  if (!result || !result.inputRecords) return 0;\n  return ((result.failedRecords || 0) / result.inputRecords) * 100;\n}\n\nfunction calculateROI(data) {\n  // ROI simplificado baseado em tempo economizado\n  const timeSaved = calculateTimeSaved(data);\n  const implementationCost = 100; // Custo estimado em horas\n  return timeSaved > implementationCost ? ((timeSaved - implementationCost) / implementationCost) * 100 : -50;\n}\n\nfunction calculateTimeSaved(data) {\n  // Tempo economizado em horas por execução\n  const manualTime = 50; // 50 minutos manual\n  const automatedTime = (data.executionMetrics?.duration || 0) / 60000; // converter para minutos\n  return Math.max(0, manualTime - automatedTime);\n}\n\nfunction generateRecommendations(data) {\n  const recommendations = [];\n  \n  if (data.executionMetrics?.status === 'success') {\n    recommendations.push('Considerar automatizar próxima tarefa da lista');\n    recommendations.push('Implementar monitoramento contínuo');\n  } else {\n    recommendations.push('Revisar critérios de sucesso');\n    recommendations.push('Analisar causas de falha');\n  }\n  \n  if ((data.executionMetrics?.duration || 0) > 60000) {\n    recommendations.push('Otimizar performance da automação');\n  }\n  \n  return recommendations;\n}\n\nfunction determineOverallStatus(data) {\n  if (data.phase === 'AUTOMATIZAR_ERROR') return 'FAILED';\n  if (data.executionMetrics?.status === 'success') return 'SUCCESS';\n  if (data.executionMetrics?.status === 'partial_success') return 'PARTIAL_SUCCESS';\n  return 'UNKNOWN';\n}\n\nfunction generateNextSteps(data) {\n  const steps = [];\n  \n  if (miaReport.overallStatus === 'SUCCESS') {\n    steps.push('Monitorar automação em produção');\n    steps.push('Documentar lições aprendidas');\n    steps.push('Iniciar próximo ciclo MIA para próxima tarefa');\n  } else {\n    steps.push('Analisar pontos de falha');\n    steps.push('Ajustar configurações');\n    steps.push('Re-executar fase de isolamento se necessário');\n  }\n  \n  return steps;\n}\n\n// Log final\nconsole.log('📊 AUTOMATIZAR - Relatório MIA gerado');\nconsole.log('🎯 Status Final:', miaReport.overallStatus);\nconsole.log('⏱️ Tempo de Execução:', miaReport.performanceMetrics.totalExecutionTime + 'ms');\nconsole.log('📈 Taxa de Sucesso:', miaReport.performanceMetrics.automationEfficiency + '%');\n\nreturn {\n  json: {\n    phase: 'MIA_COMPLETE',\n    miaReport: miaReport,\n    executionData: executionData,\n    summary: {\n      framework: 'MIA (Mapear-Isolar-Automatizar)',\n      status: miaReport.overallStatus,\n      efficiency: miaReport.performanceMetrics.automationEfficiency,\n      recommendations: miaReport.recommendations.length\n    }\n  }\n};"
  },
  "name": "📊 Relatório Final",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [2040, 120]
}

Nós de Tratamento de Erro

Tratamento de Erro Geral

{
  "parameters": {
    "functionCode": "// Tratamento de erros do Framework MIA\nconst errorData = $json;\n\nconst errorReport = {\n  timestamp: new Date().toISOString(),\n  phase: errorData.phase || 'UNKNOWN',\n  errorType: errorData.error?.message || 'Erro não especificado',\n  correlationId: errorData.correlationId || 'N/A',\n  rollbackRequired: errorData.error?.requiresRollback || false,\n  \n  // Ações de recuperação\n  recoveryActions: [\n    'Notificar equipe responsável',\n    'Registrar erro no sistema de monitoramento',\n    'Reverter para processo manual se necessário',\n    'Analisar causa raiz',\n    'Ajustar configurações para próxima execução'\n  ],\n  \n  // Dados para análise\n  debugInfo: {\n    originalData: errorData.originalConfig || null,\n    executionContext: errorData.executionContext || null,\n    lastSuccessfulStep: determineLastSuccessfulStep(errorData.phase)\n  }\n};\n\nfunction determineLastSuccessfulStep(phase) {\n  switch(phase) {\n    case 'MAPEAR': return 'Início do processo';\n    case 'ISOLAR': return 'Mapeamento concluído';\n    case 'AUTOMATIZAR': return 'Isolamento concluído';\n    case 'AUTOMATIZAR_ERROR': return 'Configuração da automação';\n    default: return 'Desconhecido';\n  }\n}\n\nconsole.error('❌ ERRO MIA - Fase:', errorData.phase);\nconsole.error('�� ERRO MIA - Detalhes:', errorData.error?.message);\nconsole.log('🔄 ERRO MIA - Rollback necessário:', errorReport.rollbackRequired);\n\nreturn {\n  json: {\n    phase: 'ERROR_HANDLING',\n    errorReport: errorReport,\n    status: 'FAILED',\n    requiresManualIntervention: true\n  }\n};"
  },
  "name": "❌ Tratamento de Erro",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [1240, 400]
}

Nó de Notificação

{
  "parameters": {
    "functionCode": "// Notificação final do Framework MIA\nconst finalData = $json;\n\n// Preparar notificação baseada no resultado\nlet notificationData;\n\nif (finalData.phase === 'MIA_COMPLETE') {\n  // Sucesso\n  notificationData = {\n    type: 'success',\n    title: '✅ Framework MIA - Execução Concluída',\n    message: `Automação implementada com sucesso!`,\n    details: {\n      status: finalData.miaReport.overallStatus,\n      efficiency: `${finalData.miaReport.performanceMetrics.automationEfficiency.toFixed(1)}%`,\n      executionTime: `${finalData.miaReport.performanceMetrics.totalExecutionTime}ms`,\n      roi: `${finalData.miaReport.performanceMetrics.roi.toFixed(1)}%`\n    },\n    nextSteps: finalData.miaReport.nextSteps\n  };\n} else if (finalData.phase === 'ERROR_HANDLING') {\n  // Erro\n  notificationData = {\n    type: 'error',\n    title: '❌ Framework MIA - Erro na Execução',\n    message: `Falha durante a execução: ${finalData.errorReport.errorType}`,\n    details: {\n      phase: finalData.errorReport.phase,\n      correlationId: finalData.errorReport.correlationId,\n      rollbackRequired: finalData.errorReport.rollbackRequired\n    },\n    recoveryActions: finalData.errorReport.recoveryActions\n  };\n} else {\n  // Status desconhecido\n  notificationData = {\n    type: 'warning',\n    title: '⚠️ Framework MIA - Status Indefinido',\n    message: 'Execução finalizada com status indefinido',\n    details: finalData\n  };\n}\n\n// Log da notificação\nconsole.log('📢 NOTIFICAÇÃO:', notificationData.title);\nconsole.log('📝 MENSAGEM:', notificationData.message);\n\nreturn {\n  json: {\n    notification: notificationData,\n    timestamp: new Date().toISOString(),\n    finalResult: finalData\n  }\n};"
  },
  "name": "📢 Notificação Final",
  "type": "n8n-nodes-base.function",
  "typeVersion": 1,
  "position": [2240, 200]
}

Configuração das Conexões

Fluxo Principal:

  1. 🚀 INÍCIO → 📊 Coleta de Dados

  2. 📊 Coleta de Dados → 🔍 Análise de Fluxo

  3. 🔍 Análise de Fluxo → 🚨 Identificar Gargalos

  4. 🚨 Identificar Gargalos → ✅ Verificar Elegibilidade

  5. ✅ Verificar Elegibilidade (TRUE) → 📋 Categorizar Tarefas

  6. 📋 Categorizar Tarefas → 🎯 Selecionar para Automação

  7. 🎯 Selecionar para Automação → ⚙️ Configurar Automação

  8. ⚙️ Configurar Automação → 🚀 Executar Processo

  9. 🚀 Executar Processo → 📊 Relatório Final

  10. �� Relatório Final → 📢 Notificação Final


Fluxo de Erro:

  • ✅ Verificar Elegibilidade (FALSE) → ❌ Tratamento de Erro

  • 🚀 Executar Processo (ERROR) → ❌ Tratamento de Erro

  • ❌ Tratamento de Erro → 📢 Notificação Final


Como Usar o Template

1. Importação

# Copie todo o JSON do workflow e importe no N8N
# Ou salve como arquivo .json e importe via interface

2. Configuração Inicial

{
  "processName": "Nome do Processo",
  "priority": "high|medium|low",
  "stakeholders": ["user1", "user2"],
  "expectedOutcome": "Descrição do resultado esperado"
}

3. Personalização

  • Modifique as funções de acordo com seu processo específico

  • Ajuste os critérios de sucesso e métricas

  • Configure notificações para seus canais preferidos

  • Adapte as validações às suas regras de negócio

4. Monitoramento

  • Acompanhe os logs em cada fase

  • Monitore as métricas de performance

  • Analise os relatórios gerados

  • Implemente melhorias baseadas no feedback


Métricas e KPIs

Métricas de Mapeamento

  • Número de etapas identificadas

  • Score de automação

  • Gargalos encontrados

  • Tempo total do processo

Métricas de Isolamento

  • Tarefas categorizadas

  • Quick wins identificados

  • Prioridades definidas

  • ROI estimado

Métricas de Automação

  • Tempo de execução

  • Taxa de sucesso

  • Eficiência alcançada

  • Economia de tempo


Customizações Avançadas

Integração com APIs Externas

{
  "parameters": {
    "url": "={{$json.apiEndpoint}}",
    "method": "POST",
    "body": {
      "processData": "={{$json.processInput}}"
    }
  },
  "name": "🔗 API Integration",
  "type": "n8n-nodes-base.httpRequest"
}

Armazenamento de Dados

{
  "parameters": {
    "operation": "create",
    "table": "mia_executions",
    "columns": "execution_id, phase, status, metrics, timestamp"
  },
  "name": "💾 Save to Database",
  "type": "n8n-nodes-base.postgres"
}

Notificações Avançadas

{
  "parameters": {
    "channel": "#automation",
    "text": "Framework MIA - {{$json.notification.title}}\n{{$json.notification.message}}"
  },
  "name": "📱 Slack Notification",
  "type": "n8n-nodes-base.slack"
}

Este template fornece uma base sólida para implementar o Framework MIA em qualquer processo que você deseje automatizar. Cada fase é claramente definida e pode ser adaptada às suas necessidades específicas!


Caso queira ajuda para implementar automações de IA no seu negócio, chame o time de especialistas da Sambatech.

Comentários

Avaliado com 0 de 5 estrelas.
Ainda sem avaliações
Adicione uma avaliação

© 2025 by Gustavo Caetano

bottom of page