Conceitos Fundamentais

conceitos
arquitetura
fundamentos

Entenda os conceitos principais do Tarefa AI: Tasks, Schedules, Executions, Models e Integrations

Por Tarefa AI Team17/10/2025
Nesta Página

Conceitos Fundamentais

Este guia explica os conceitos essenciais do Tarefa AI para que você possa aproveitar ao máximo a plataforma.


Visão Geral da Arquitetura

Tarefa AI é uma plataforma de agendamento e execução de tarefas com IA. Aqui está como tudo se conecta:

graph TD
    A[Usuário] -->|Cria| B[Task]
    B -->|Possui| C[Schedule]
    B -->|Usa| D[AI Model]
    B -->|Pode ter| E[Files/Images]
    C -->|Dispara| F[Execution]
    F -->|Gera| G[Output]
    F -->|Aciona| H[Notifications]
    H -->|Envia para| I[Email/WhatsApp/Notion/Webhook]

1. Tasks (Tarefas)

O que é uma Task?

Uma Task é a unidade fundamental do Tarefa AI. Ela representa:

  • O que fazer: Um prompt para o modelo de IA
  • Quando fazer: Agendamento (uma vez, recorrente, ou manual)
  • Como fazer: Configurações (modelo, temperatura, tokens, etc.)
  • O que fazer depois: Notificações e integrações

Anatomia de uma Task

interface Task {
  // Identificação
  id: string;
  name: string;
  description?: string;
 
  // Prompts
  systemPrompt: string;      // Instruções para a IA
  userMessage?: string;      // Input específico
 
  // Modelo de IA
  model: string;             // Ex: "google/gemini-2.5-pro"
  temperature?: number;      // 0-1 (criatividade)
  maxTokens?: number;        // Limite de resposta
 
  // Agendamento
  scheduleType: "once" | "recurring" | "manual";
  cronExpression?: string;   // Para recurring
  timezone: string;          // Ex: "America/Sao_Paulo"
 
  // Estado
  isActive: boolean;
 
  // Multimodal
  fileIds?: string[];        // IDs de arquivos anexados
 
  // Notificações
  notifications: {
    email?: boolean;
    whatsapp?: boolean;
    webhook?: string;
    notion?: boolean;
    figma?: boolean;
  };
 
  // Metadados
  userId: string;
  createdAt: Date;
  updatedAt: Date;
}

Tipos de Tasks

1. Task Manual (One-Time)

Executa uma única vez quando você clicar em "Run Now":

{
  scheduleType: "manual",
  name: "Análise de Sentimento de Texto"
}

Casos de uso:

  • Análise pontual de dados
  • Geração de conteúdo sob demanda
  • Testes e experimentos

2. Task Única (Once)

Executa uma vez em uma data/hora específica:

{
  scheduleType: "once",
  scheduledFor: "2025-10-20T14:00:00Z",
  name: "Relatório Trimestral Q4"
}

Casos de uso:

  • Relatórios agendados para datas específicas
  • Lembretes futuros
  • Tarefas de conclusão de projeto

3. Task Recorrente (Recurring)

Executa repetidamente em um padrão:

{
  scheduleType: "recurring",
  cronExpression: "0 9 * * 1-5", // Seg-Sex às 9h
  name: "Resumo Diário de Vendas"
}

Casos de uso:

  • Relatórios diários/semanais/mensais
  • Monitoramento contínuo
  • Automações recorrentes

2. Schedules (Agendamentos)

O que é um Schedule?

Um Schedule define quando uma task deve ser executada. Tarefa AI usa expressões cron para máxima flexibilidade.

Anatomia de uma Cron Expression

┌───────────── minuto (0 - 59)
│ ┌───────────── hora (0 - 23)
│ │ ┌───────────── dia do mês (1 - 31)
│ │ │ ┌───────────── mês (1 - 12)
│ │ │ │ ┌───────────── dia da semana (0 - 6, 0 = Domingo)
│ │ │ │ │
* * * * *

Exemplos Práticos

Diário às 9h

0 9 * * *
Executa todos os dias às 9h da manhã
{
  scheduleType: "recurring",
  cronExpression: "0 9 * * *",
  timezone: "America/Sao_Paulo"
}

Segunda a Sexta às 8h30

30 8 * * 1-5

A cada 6 horas

0 */6 * * *

Horários: 00:00, 06:00, 12:00, 18:00

Todo dia 1º do mês às 10h

0 10 1 * *

Caso de uso: Relatórios mensais automáticos

Toda segunda às 9h

0 9 * * 1

Caso de uso: Resumo semanal de métricas

Timezones

Sempre especifique o timezone para evitar confusões:

{
  timezone: "America/Sao_Paulo",    // BRT/BRST
  // ou
  timezone: "America/New_York",     // EST/EDT
  // ou
  timezone: "Europe/London"         // GMT/BST
}

3. Executions (Execuções)

O que é uma Execution?

Uma Execution é o registro de uma vez que uma task foi executada. Ela contém:

  • Resultado: Output gerado pela IA
  • Metadata: Tokens usados, tempo de execução, custos
  • Status: Success, Error, Timeout, etc.
  • Logs: Processo completo de execução

Anatomia de uma Execution

interface Execution {
  // Identificação
  id: string;
  taskId: string;
 
  // Estado
  status: "pending" | "running" | "completed" | "failed";
 
  // Input/Output
  input: {
    systemPrompt: string;
    userMessage?: string;
    model: string;
    files?: File[];
  };
 
  output: {
    content: string;        // Resposta da IA
    raw?: object;           // Resposta completa da API
  };
 
  // Métricas
  metadata: {
    tokensUsed: {
      prompt: number;
      completion: number;
      total: number;
    };
    executionTime: number;  // Em segundos
    cost: number;           // Em USD
    model: string;
  };
 
  // Erro (se houver)
  error?: {
    message: string;
    code: string;
    stack?: string;
  };
 
  // Notificações
  notificationsSent: {
    email?: { success: boolean; sentAt?: Date };
    whatsapp?: { success: boolean; sentAt?: Date };
    webhook?: { success: boolean; sentAt?: Date };
    notion?: { success: boolean; sentAt?: Date };
  };
 
  // Timestamps
  startedAt: Date;
  completedAt?: Date;
  createdAt: Date;
}

Ciclo de Vida de uma Execution

stateDiagram-v2
    [*] --> Pending
    Pending --> Running: Scheduler inicia
    Running --> Completed: Sucesso
    Running --> Failed: Erro
    Running --> Timeout: Tempo esgotado
    Completed --> [*]
    Failed --> [*]
    Timeout --> [*]

Status de Execução

StatusDescriçãoÍcone
pendingNa fila, aguardando execução🕐
runningEm execução agora
completedConcluída com sucesso
failedFalhou (erro na API, prompt, etc.)
timeoutTimeout (excedeu tempo máximo)⏱️

Visualizar Executions

No Dashboard:

  1. Clique em uma Task
  2. Vá para a aba "Executions"
  3. Veja a lista de todas as execuções
  4. Clique em uma execução para ver detalhes completos

4. AI Models (Modelos de IA)

O que são AI Models?

Tarefa AI se conecta ao OpenRouter, que dá acesso a 200+ modelos de diferentes provedores.

Categorias de Modelos

1. Modelos de Texto (Text-Only)

Processam apenas texto:

  • Claude 3 Opus (anthropic/claude-3-opus)
  • GPT-4 Turbo (openai/gpt-4-turbo)
  • Mistral Large (mistralai/mistral-large)

2. Modelos Multimodais (Text + Images)

Processam texto E imagens:

  • Gemini 2.5 Pro (google/gemini-2.5-pro) ⭐ Recomendado
  • Gemini 2.5 Flash (google/gemini-2.5-flash) ⚡ Rápido
  • Claude 3.5 Sonnet (anthropic/claude-3.5-sonnet)
  • GPT-4 Vision (openai/gpt-4-vision)

3. Modelos Especializados

  • Code: deepseek/deepseek-coder, qwen/qwen-2.5-coder
  • Reasoning: openai/o3-mini, deepseek/deepseek-r1
  • Long Context: google/gemini-1.5-pro-latest (2M tokens!)

Parâmetros do Modelo

Temperature (Criatividade)

{
  temperature: 0.0  // Determinístico, preciso
  temperature: 0.5  // Balanceado
  temperature: 1.0  // Criativo, variado
}

Max Tokens (Limite de Resposta)

{
  maxTokens: 1000   // Respostas curtas
  maxTokens: 4000   // Respostas médias
  maxTokens: 16000  // Respostas longas
}

Top P (Nucleus Sampling)

{
  topP: 1.0   // Considera todas as opções (padrão)
  topP: 0.9   // Mais focado
  topP: 0.5   // Muito focado
}

5. Files & Multimodal (Arquivos e Multimodalidade)

O que é Multimodal?

Multimodal significa que você pode enviar imagens junto com o prompt de texto.

Casos de Uso

Análise de Imagens

{
  name: "Análise de Screenshot de UI",
  model: "google/gemini-2.5-flash",
  systemPrompt: "Analise esta interface e sugira melhorias de UX",
  files: [uploadedScreenshot]
}

OCR (Extração de Texto)

{
  name: "Extrair Texto de Documento",
  model: "google/gemini-2.5-pro",
  systemPrompt: "Extraia todo o texto desta imagem e formate como Markdown",
  files: [scannedDocument]
}

Comparação de Imagens

{
  name: "Comparar Versões de Design",
  model: "anthropic/claude-3.5-sonnet",
  systemPrompt: "Compare estas duas versões do design e liste as diferenças",
  files: [version1, version2]
}

Formatos Suportados

  • Imagens: PNG, JPG, JPEG, WEBP, GIF
  • Tamanho máximo: 20MB por arquivo
  • Múltiplos arquivos: Até 5 imagens por task

6. Notifications & Integrations (Notificações e Integrações)

Tipos de Notificação

1. Email

{
  notifications: {
    email: true
  }
}

Você receberá:

  • ✅ Assunto: Nome da task + status
  • ✅ Corpo: Output completo da IA
  • ✅ Metadata: Tokens, tempo, custo

2. WhatsApp

{
  notifications: {
    whatsapp: true
  }
}

Requer: Evolution API configurada

3. Webhook

{
  notifications: {
    webhook: "https://seu-servidor.com/api/webhook"
  }
}

Payload enviado:

{
  "taskId": "task_123",
  "executionId": "exec_456",
  "status": "completed",
  "output": "...",
  "metadata": { ... }
}

4. Notion

{
  notifications: {
    notion: true
  }
}

Cria automaticamente:

  • Nova página no seu Notion
  • Título: Nome da task + data
  • Conteúdo: Output formatado

5. Figma

{
  notifications: {
    figma: true
  }
}

Adiciona comentário:

  • No arquivo Figma configurado
  • Com o output da task

7. User & Plans (Usuário e Planos)

Planos Disponíveis

PlanoExecuções/mêsPreço
Free50Grátis
Starter500$9/mês
Pro2.000$29/mês
Business10.000$99/mês

Gestão de API Keys

Suas API keys são:

  • 🔐 Criptografadas com Fernet (AES-256)
  • 🔒 Nunca expostas no frontend
  • 🗄️ Armazenadas apenas no backend
  • 🔑 Descriptografadas apenas no momento da execução

8. Security & Privacy (Segurança e Privacidade)

Como seus dados são protegidos

Criptografia

// API Keys são criptografadas antes de salvar
const encrypted = fernet.encrypt(apiKey);
 
// E descriptografadas apenas quando necessário
const decrypted = fernet.decrypt(encrypted);

Autenticação

  • JWT tokens com expiração de 30 dias
  • Refresh tokens para sessões longas
  • Cookie httpOnly + secure + sameSite

Autorização

// Toda request valida ownership
if (task.userId !== currentUser.id) {
  throw new UnauthorizedException();
}

Compliance

  • GDPR: Direito de deletar dados
  • LGPD: Conformidade com lei brasileira
  • SOC 2: Em progresso

Conceitos Avançados

Rate Limiting

Tarefa AI respeita os limites de rate das APIs:

  • OpenRouter: 200 req/min (Free), 500 req/min (Paid)
  • Notion: 3 req/sec
  • Figma: 100 req/min

Retry Logic

Se uma execution falha, Tarefa AI retenta automaticamente:

  1. Primeira tentativa: Imediata
  2. Segunda tentativa: Após 5 minutos
  3. Terceira tentativa: Após 30 minutos

Logs & Debugging

Toda execution gera logs detalhados:

{
  "timestamp": "2025-10-17T10:30:00Z",
  "level": "info",
  "message": "Execution started",
  "data": {
    "taskId": "task_123",
    "model": "google/gemini-2.5-pro"
  }
}

Próximos Passos

Agora que você entende os conceitos fundamentais:


Glossário Rápido

TermoDefinição
TaskUma tarefa agendada com IA
ScheduleQuando a task deve executar (cron)
ExecutionRegistro de uma execução da task
ModelModelo de IA usado (ex: Gemini, Claude)
PromptInstrução enviada para a IA
System PromptInstruções gerais de comportamento
User MessageInput específico para a task
MultimodalSuporte a texto + imagens
Cron ExpressionPadrão de agendamento (ex: 0 9 * * *)
TimezoneFuso horário da execução
TokenUnidade de processamento de texto (~4 chars)
TemperatureNível de criatividade (0-1)

💡 Você dominou os conceitos!

Agora você entende como Tasks, Schedules, Executions e Models se conectam. Hora de colocar em prática!