Como automatizar tarefas repetitivas usando IA

Sabe aquela tarefa chata, repetitiva, que você olha para a planilha e pensa: "De novo isso?" Pois é, eu vivo isso quase todo dia. Não importa se é categorizar milhares de linhas de feedback de clientes, extrair informações de e-mails para preencher um Google Sheets, ou padronizar descrições de produtos que chegam de mil fontes diferentes. O trabalho manual é um inferno, e a gente sabe que gasta um tempo absurdo que poderia ser usado em algo mais útil. Eu já perdi horas da minha vida nisso, e a frustração é real.

Mas, nos últimos tempos, uma coisa tem mudado a forma como eu encaro essas rotinas: a Inteligência Artificial. E não estou falando de IA de filme ou de consultor que vende solução mágica. Estou falando da IA de verdade, aquela que a gente coloca para rodar na prática, chamando uma API, ajustando um prompt, e vendo a coisa acontecer. É o tipo de IA que eu uso no dia a dia para me livrar de tarefas que me sugavam a energia.

A ideia aqui é mostrar como a gente pega um problema repetitivo, que geralmente envolve dados em texto, planilhas e integrações, e coloca a IA pra trabalhar. Não é sobre o futuro distante, é sobre o agora, com as ferramentas que eu e você já usamos.

Identificando o Chato e Como a IA Pode Ajudar

O primeiro passo é sempre o mesmo: qual é a tarefa que me faz querer jogar o computador pela janela? Geralmente, são coisas que exigem algum tipo de "leitura" e "interpretação" que uma regra simples IF/ELSE não consegue resolver. Pense em:

Classificar e-mails de suporte por tipo de problema (bug, dúvida, sugestão, etc.).
Extrair nomes, valores e datas de faturas ou relatórios escaneados (ou até de texto puro).
Resumir textos longos (reviews de produtos, transcrições de reuniões) em tópicos chave.
Gerar pequenas descrições ou variações de texto com base em um modelo.
Converter texto não estruturado em JSON ou outro formato estruturado para um sistema.

Eu passei por um caso clássico recentemente. Recebíamos centenas de feedbacks de clientes por um formulário de texto livre. A gente precisava categorizar isso em, tipo, 15 categorias diferentes para entender os problemas mais comuns. Fazer isso na mão era inviável. Uma pessoa ficava meio período só lendo e jogando numa coluna de categoria. Além de lento, era inconsistente, porque cada um interpretava de um jeito. Aí entra a IA, mais especificamente os LLMs (Large Language Models) que você acessa via API.

A Mágica da API: Conectando Nossas Ferramentas à IA

A beleza da coisa é que a maioria dos modelos de IA que realmente resolvem esses problemas está disponível via API. Isso significa que você não precisa ter um supercomputador ou ser um cientista de dados para usar. Você só precisa saber fazer uma requisição HTTP.

No meu mundo, isso geralmente se traduz em:

Python: Se a tarefa é mais robusta, envolve muitos dados, ou precisa de um servidor rodando, Python é o caminho. A biblioteca `requests` é minha melhor amiga para chamar APIs, e o `pandas` para manipular os dados antes e depois.
Apps Script (Google Sheets): Para automações mais leves, que vivem dentro do ecossistema do Google Workspace. É perfeito para processar dados direto de uma planilha, e o `UrlFetchApp` faz o papel do `requests` para bater nas APIs.

O fluxo básico é sempre o mesmo:

Pego o dado "bruto" (o feedback do cliente, o texto do e-mail).
Mando esse dado para a API da IA, junto com uma "instrução" (o prompt).
A IA me devolve uma resposta (a categoria, o dado extraído, o resumo).
Pego essa resposta e uso para preencher minha planilha, mandar um e-mail, etc.

Construindo o Cérebro: A Arte do Prompt Engineering

Aqui é onde a coisa fica interessante e onde a experiência prática faz toda a diferença. O "prompt" é a instrução que você dá para a IA. Não é só jogar o texto lá e pedir "me categoriza". Você precisa ser explícito, dar exemplos e definir o formato da saída. É como treinar um estagiário muito inteligente, mas que não tem senso comum.

Voltando ao exemplo do feedback do cliente, meu prompt inicial era algo tipo:


"Classifique o feedback abaixo em uma das seguintes categorias: [Lista de 15 categorias]. Retorne APENAS a categoria. Se não se encaixar em nenhuma, retorne 'Outros'.
Feedback: 'Minha conta foi bloqueada e não consigo acessar, preciso de ajuda urgente!'
"

No começo, a IA errava. Às vezes, inventava uma categoria que não existia. Ou respondia com uma frase completa em vez de apenas a categoria. O problema? Meu prompt não era bom o suficiente. Precisei refinar:

Dei exemplos (few-shot learning): "Aqui estão alguns exemplos de feedback e suas categorias corretas: [Feedback 1 -> Categoria 1], [Feedback 2 -> Categoria 2]". Isso ajuda muito a IA a entender o padrão.
Defini o formato da saída explicitamente: "Sua resposta deve ser um JSON com a chave 'categoria' e o valor da categoria escolhida. Exemplo: `{"categoria": "Problema de Acesso"}`". Isso é crucial para automação, porque facilita muito a parsear a resposta.
Instruções negativas: "NÃO adicione explicações ou qualquer outro texto. APENAS o JSON."

Depois de algumas iterações, o prompt ficou bem mais robusto. Essa fase de "prompt engineering" é a mais demorada, mas é onde você garante que a automação vai funcionar direito. Não tenha medo de gastar tempo aqui. Eu já errei muito achando que um prompt simples bastaria, e gastei muito mais tempo corrigindo depois.

Integrando Tudo: Do Sheet ao Código, do Código à IA

Vamos pegar um cenário prático: uma planilha no Google Sheets com uma coluna de "Feedback" e eu quero preencher uma coluna "Categoria" automaticamente.

Com Apps Script (para o Google Sheets):

Eu criaria uma função no Apps Script que lê a coluna de feedback, itera por cada linha, chama a API da IA com o prompt e o feedback, e depois escreve a categoria na célula ao lado. Assim que a planilha é salva ou uma função é disparada manualmente, ela roda e preenche. Um pedaço de código seria mais ou menos assim:


function categorizarFeedbacks() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Feedbacks");
  const data = sheet.getDataRange().getValues(); // Pega todos os dados
  
  // A primeira linha geralmente são os cabeçalhos
  for (let i = 1; i < data.length; i++) { 
    const feedback = data[i][0]; // Supondo feedback na coluna A (índice 0)
    
    if (feedback && !data[i][1]) { // Se tem feedback e a categoria (coluna B) está vazia
      try {
        const categoria = chamarAPI_IA(feedback); // Função que chama a API
        sheet.getRange(i + 1, 2).setValue(categoria); // Escreve na coluna B (índice 2)
        SpreadsheetApp.flush(); // Garante que a escrita seja efetivada
      } catch (e) {
        Logger.log("Erro ao categorizar feedback da linha " + (i + 1) + ": " + e.message);
        sheet.getRange(i + 1, 2).setValue("ERRO"); // Marca para revisão manual
      }
    }
  }
}

function chamarAPI_IA(textoFeedback) {
  const apiKey = "SUA_API_KEY"; // NÃO coloque sua chave direto no código, use PropertiesService!
  const apiUrl = "https://api.openai.com/v1/chat/completions"; // Exemplo, pode ser outra API
  
  const prompt = `Classifique o seguinte feedback do cliente em uma única categoria da lista: 'Problema de Acesso', 'Bug de Interface', 'Sugestão de Funcionalidade', 'Dúvida Geral', 'Problema de Pagamento', 'Outros'. Retorne APENAS a categoria.
Feedback: "${textoFeedback}"
Categoria:`;

  const headers = {
    "Authorization": "Bearer " + apiKey,
    "Content-Type": "application/json"
  };
  
  const payload = JSON.stringify({
    model: "gpt-3.5-turbo", // Ou outro modelo que você esteja usando
    messages: [{role: "user", content: prompt}],
    max_tokens: 50, // Limita o tamanho da resposta
    temperature: 0.1 // Torna a resposta mais determinística
  });
  
  const options = {
    "method": "post",
    "headers": headers,
    "payload": payload,
    "muteHttpExceptions": true // Importante para pegar erros da API
  };
  
  const response = UrlFetchApp.fetch(apiUrl, options);
  const responseCode = response.getResponseCode();
  const responseBody = response.getContentText();
  
  if (responseCode === 200) {
    const jsonResponse = JSON.parse(responseBody);
    // Assumindo que a resposta está em choices[0].message.content
    // É preciso um pouco de parseamento aqui dependendo da API
    const categoria = jsonResponse.choices[0].message.content.trim();
    return categoria;
  } else {
    // Tratar erros de API
    throw new Error(`Erro na API (${responseCode}): ${responseBody}`);
  }
}

Percebe que eu uso o `PropertiesService` para chaves de API em produção, mas para um exemplo rápido, deixei direto no código. Isso é um detalhe pequeno que faz diferença na segurança e manutenção. Ah, e o `SpreadsheetApp.flush()` é um truque para garantir que as alterações sejam salvas, especialmente em loops longos.

Com Python (para algo mais robusto ou fora do Sheets):

Se eu tivesse os feedbacks em um banco de dados, ou um arquivo CSV, ou até mesmo baixando e-mails via API de e-mail, Python seria a escolha. Eu faria um script que lê os dados, chama a API da IA, e depois escreve de volta no banco, ou em um novo CSV, ou atualiza a planilha via API do Google Sheets.


import requests
import pandas as pd
import json
import os # Para variáveis de ambiente

def chamar_api_ia_python(texto_feedback):
    api_key = os.getenv("OPENAI_API_KEY") # Pega de variável de ambiente, bem mais seguro
    api_url = "https://api.openai.com/v1/chat/completions"
    
    prompt = f"""Classifique o seguinte feedback do cliente em uma única categoria da lista: 'Problema de Acesso', 'Bug de Interface', 'Sugestão de Funcionalidade', 'Dúvida Geral', 'Problema de Pagamento', 'Outros'. Retorne APENAS a categoria.
Feedback: "{texto_feedback}"
Categoria:"""

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-3.5-turbo",
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 50,
        "temperature": 0.1
    }
    
    try:
        response = requests.post(api_url, headers=headers, json=payload)
        response.raise_for_status() # Lança exceção para erros HTTP
        json_response = response.json()
        categoria = json_response["choices"][0]["message"]["content"].strip()
        return categoria
    except requests.exceptions.RequestException as e:
        print(f"Erro na API: {e}")
        return "ERRO_API"
    except json.JSONDecodeError:
        print(f"Erro ao decodificar JSON: {response.text}")
        return "ERRO_PARSING"
    except KeyError:
        print(f"Estrutura de resposta inesperada: {response.text}")
        return "ERRO_ESTRUTURA"

def processar_feedbacks_python(caminho_csv_entrada, caminho_csv_saida):
    try:
        df = pd.read_csv(caminho_csv_entrada)
    except FileNotFoundError:
        print(f"Arquivo não encontrado: {caminho_csv_entrada}")
        return

    if 'feedback_texto' not in df.columns:
        print("Coluna 'feedback_texto' não encontrada no CSV.")
        return

    df['categoria_ia'] = df['feedback_texto'].apply(lambda x: chamar_api_ia_python(x) if pd.notna(x) else None)
    
    df.to_csv(caminho_csv_saida, index=False)
    print(f"Processamento concluído. Resultados salvos em {caminho_csv_saida}")

if __name__ == "__main__":
    # Exemplo de uso:
    # Crie um arquivo 'feedbacks.csv' com uma coluna chamada 'feedback_texto'
    # E defina a variável de ambiente OPENAI_API_KEY
    # Ex: os.environ['OPENAI_API_KEY'] = 'sk-sua_chave_aqui'
    processar_feedbacks_python('feedbacks_entrada.csv', 'feedbacks_saida.csv')

O Python é mais verboso para tratamento de erros, mas dá um controle muito maior. Usar variáveis de ambiente para chaves de API é uma prática essencial que eu aprendi na marra, depois de acidentalmente commitar chaves em repositórios algumas vezes (e ter que revogar tudo correndo, um pesadelo).

Validação e Refinamento Contínuo

Uma automação com IA não é "set and forget". Você precisa validar. No caso do feedback, eu pegava uma amostra aleatória das categorias geradas e conferia manualmente. Se a taxa de erro era alta (tipo, acima de 5-10%), eu voltava para o prompt. Mudava as categorias, adicionava mais exemplos, alterava a temperatura do modelo (para menos criatividade, mais determinismo). É um processo iterativo, e é aí que você percebe que a IA é uma ferramenta poderosa, mas não um gênio da lâmpada.

O mais importante é entender que a IA é boa em reconhecer padrões, mas a qualidade do padrão que ela reconhece depende do que você ensina a ela (o prompt) e dos dados que você dá. Não espere que ela faça milagres com instruções vagas ou dados ruins.

Manual vs. Automatizado: A Diferença na Prática

Para deixar claro o impacto, veja a diferença entre o jeito "raiz" de resolver o problema de categorização de feedback e o jeito que eu faço hoje:

Aspecto	Jeito Manual/Demorado	Jeito Automatizado (com IA)
Tempo Gasto (1000 feedbacks)	8-16 horas de trabalho manual intenso	5-15 minutos (tempo de execução do script + validação de amostra)
Consistência	Baixa a média (varia entre pessoas e humor)	Alta (IA segue o prompt, erros são previsíveis)
Custo	Horas de trabalho de um funcionário	Custo da API da IA (geralmente centavos por 1000 chamadas) + tempo de desenvolvimento inicial
Escalabilidade	Muito baixa (cada feedback adicional exige mais tempo)	Alta (aumentar o volume é quase sem custo de tempo)
Qualidade da Análise	Pode ser superficial devido à fadiga humana	Mais profunda, permite foco em anomalias e insights reais
Saturação Mental	Altíssima, tarefa exaustiva e desmotivadora	Nula para o operador, que foca na validação e melhoria
Complexidade para Implementar	Nenhuma, basta ler e escrever	Exige conhecimento de código (Python/Apps Script), APIs e prompt engineering

Essa tabela mostra o porquê de eu ter investido tanto tempo aprendendo isso. Não é só economizar tempo, é evitar aquela sensação de estar "jogando tempo fora" em algo que uma máquina pode fazer melhor e mais rápido.

O Que Dá Errado (E Sempre Dá)

É importante ser realista. Automação com IA não é mágica e tem seus próprios problemas. Aqui estão algumas das coisas que me tiram o sono:

1. Prompt Tuning é um Inferno (Às Vezes)

Você acha que o prompt está perfeito, testa com 10 exemplos e funciona. Aí coloca 1000 feedbacks e a IA começa a inventar. Às vezes, uma palavra mal escolhida no prompt pode mudar completamente o comportamento do modelo. Eu já cheguei a passar um dia inteiro otimizando um prompt para uma tarefa que parecia simples de extração de dados de contratos. É um jogo de paciência, tentativa e erro, e entender como a IA "pensa".

2. Custos Inesperados da API

No começo, é fácil esquecer que cada chamada à API custa. Se você está testando e não limita o número de chamadas, ou se o script entra em loop, o que era para ser alguns centavos pode virar uma conta de dezenas ou centenas de dólares. Sempre defina limites, monitore o uso e use modelos mais baratos para testes. Eu já tive um susto com isso rodando um script em massa sem otimização.

3. Alucinações da IA (Ela Inventa Coisas)

Especialmente com modelos menos controlados ou prompts mais abertos, a IA pode "alucinar", ou seja, gerar informações que não estão presentes no texto original. Por exemplo, inventar um nome de cliente que não existe. Isso é perigoso para dados críticos. Por isso, a validação humana de uma amostra é fundamental, e o prompt deve sempre guiar a IA para extrair APENAS o que está ali, ou escolher de uma lista pré-definida.

4. Limites de Uso do Apps Script

O Apps Script é ótimo, mas tem limites de execução. Tempo máximo de 6 minutos, número de chamadas de API, quantidade de dados que pode processar por dia. Se você tem milhares de linhas para processar, pode ser que o script não termine ou estoure os limites. Para grandes volumes, Python rodando em um servidor ou localmente é mais confiável. Eu já perdi horas tentando otimizar um script para ficar dentro dos limites do Apps Script, quando a solução era simplesmente mudar para Python.

5. Lidar com Respostas Inconsistentes da API

Mesmo com um prompt "perfeito", a IA pode devolver a resposta em um formato ligeiramente diferente do esperado. Em vez de JSON, um texto. Ou o JSON com chaves diferentes. Seu código de parsing (a parte que lê a resposta da IA) precisa ser robusto e prever essas variações, senão ele quebra. É aí que um bom tratamento de erros em Python ou try-catch no Apps Script salva sua vida.

6. Manutenção de Prompts e Modelos

As APIs e os modelos de IA evoluem. Um prompt que funcionava perfeitamente hoje pode ter resultados diferentes amanhã se a OpenAI (ou quem quer que seja) atualizar o modelo. Ou, os requisitos do seu negócio mudam, e você precisa adicionar uma nova categoria. Prompts não são "write once", eles precisam de manutenção e ajustes periódicos. É como um código, mas em linguagem natural.

FAQ: Perguntas Rápidas e Práticas

Aqui estão três perguntas que eu recebo bastante, com as respostas diretas que eu daria a um colega de trabalho:

P: Qual modelo de IA devo usar para começar?

R: Para tarefas de texto como classificação e extração, comece com modelos de linguagem mais eficientes em custo-benefício, como o GPT-3.5 Turbo da OpenAI ou os modelos Gemini da Google. Eles são rápidos e têm um bom equilíbrio entre capacidade e preço. Use os modelos mais caros (GPT-4, Gemini Advanced) só se a tarefa exigir uma inteligência ou raciocínio muito específicos que os mais simples não dão conta. Teste sempre primeiro com os mais baratos.

P: Como eu garanto que meus dados sensíveis não vazem para a IA?

R: Cuidado redobrado. Primeiro, evite enviar dados sensíveis se a tarefa não exige. Se precisar enviar, verifique a política de privacidade do provedor da IA: a maioria das grandes empresas oferece opções de não usar seus dados para treinamento do modelo. Modelos "self-hosted" (rodando na sua própria infraestrutura) ou soluções on-premise são mais seguros para dados ultrassensíveis, mas são mais complexos de configurar e manter. Em Sheets e Apps Script, não armazene credenciais diretamente no código, use o `PropertiesService`.

P: É realmente caro automatizar tarefas com IA?

R: Depende. Para pequenas e médias automações, o custo da API da IA é geralmente baixo, centavos por mil requisições. O maior "custo" é o tempo de desenvolvimento inicial (escrever o código, ajustar o prompt) e a manutenção. Se você está substituindo horas de trabalho humano por uma automação de centavos, a economia é gigantesca. Mas se a automação é mal otimizada e faz milhares de chamadas desnecessárias, ou se você usa um modelo muito caro para uma tarefa simples, aí sim pode ficar caro. Planejamento e monitoramento são chave.

Conclusão

Automação com IA não é mágica, nem é um bicho de sete cabeças. É mais uma ferramenta poderosa no nosso cinto, especialmente para quem vive entre planilhas, scripts e APIs. Passei por muita frustração, erro de prompt, conta de API salgada e script que parou de funcionar do nada. Mas cada um desses problemas me ensinou algo. Hoje, quando olho para uma tarefa repetitiva, a primeira coisa que penso é: "Como a IA pode me tirar disso?". E na maioria das vezes, ela pode. Libera um tempo precioso para o que realmente importa, e isso, para mim, não tem preço.

A Mente Vetorial

Pesquisar este blog