Da intenção ao agente: como implementar IA generativa no atendimento ao cliente

A promessa de IA no atendimento ao cliente existe desde os primeiros chatbots de regras dos anos 2000. O que mudou com os LLMs não é apenas a qualidade das respostas — é o modelo de construção. Você não precisa mais mapear 500 intenções manualmente nem manter uma árvore de decisão com centenas de nós. Você descreve o comportamento desejado, fornece o contexto correto, e o modelo generaliza. Este guia mostra como implementar isso de forma que funcione em produção, não apenas em demo.

Os três níveis de IA no atendimento

Não existe uma solução única — existe um espectro de complexidade e capacidade:

Nível 1 — FAQ inteligente: O modelo responde perguntas com base em documentação fornecida. Não executa ações. Escala para humano se não souber. Implementação em dias. Resolve 30-40% dos contatos típicos.

Nível 2 — Agente com RAG: O modelo consulta uma base de conhecimento vetorial (manuais, políticas, histórico de conversas) antes de responder. Respostas contextualizadas com informações atuais. Resolve 50-70% dos contatos quando bem implementado.

Nível 3 — Agente com tools: O modelo executa ações reais: consultar status de pedido, atualizar cadastro, abrir ticket, processar reembolso. Requer integração com sistemas de negócio e guardrails rigorosos de segurança. Potencial de resolução >80%.

Arquitetura do Nível 1: FAQ inteligente com RAG simples

public class AtendimentoService
{
    private readonly ILlmClient _llm;
    private readonly IVectorStore _vectorStore;

    public async Task<RespostaAtendimento> ResponderAsync(
        string perguntaCliente,
        string? historicoConversa,
        CancellationToken ct)
    {
        // 1. Busca contexto relevante na base de conhecimento
        var contexto = await _vectorStore.BuscarAsync(perguntaCliente, topK: 5, ct);

        if (!contexto.Any())
        {
            return new RespostaAtendimento(
                Texto: null,
                DeveEscalar: true,
                Motivo: "Sem contexto relevante na base de conhecimento");
        }

        // 2. Constrói prompt com contexto
        var prompt = $"""
            Você é o assistente de atendimento da Acme. Responda com base APENAS
            nas informações abaixo. Se não encontrar a resposta, diga que vai
            transferir para um atendente humano.

            Base de conhecimento:
            {string.Join("\n---\n", contexto.Select(c => c.Texto))}

            Histórico da conversa:
            {historicoConversa ?? "Início da conversa"}

            Pergunta do cliente: {perguntaCliente}

            Regras:
            - Nunca invente informações não presentes na base de conhecimento
            - Se não tiver certeza, transfira para humano
            - Seja direto e conciso (máximo 3 parágrafos)
            - Se o cliente estiver insatisfeito, transfira imediatamente para humano
            """;

        var resposta = await _llm.CompletarAsync(prompt, ct);

        // 3. Detecta se deve escalar
        var deveEscalar = DetectarEscalada(resposta, perguntaCliente);

        return new RespostaAtendimento(
            Texto: deveEscalar ? null : resposta,
            DeveEscalar: deveEscalar,
            Motivo: deveEscalar ? "Detecção de insatisfação ou dúvida complexa" : null);
    }

    private bool DetectarEscalada(string resposta, string pergunta)
    {
        // Padrões que indicam que o modelo não soube responder
        var padroesDuvida = new[]
        {
            "não tenho informação", "não encontrei", "transferir para",
            "falar com um atendente", "não tenho certeza"
        };

        return padroesDuvida.Any(p =>
            resposta.Contains(p, StringComparison.OrdinalIgnoreCase));
    }
}

Arquitetura do Nível 3: agente com tools

Para um agente que executa ações reais, a arquitetura usa o padrão Tool Use (Function Calling):

// Definição das ferramentas disponíveis para o agente
public static class AtendimentoTools
{
    public static readonly Tool[] Todas = new[]
    {
        new Tool(
            Name: "consultar_pedido",
            Description: "Consulta o status atual de um pedido pelo número",
            Parameters: new { numeroPedido = new { type = "string", description = "Número do pedido (ex: PED-12345)" } }
        ),
        new Tool(
            Name: "registrar_reclamacao",
            Description: "Registra uma reclamação formal no sistema de CRM",
            Parameters: new
            {
                descricao = new { type = "string" },
                categoria = new { type = "string", enum = new[] { "produto", "entrega", "cobrança", "outro" } }
            }
        ),
        new Tool(
            Name: "iniciar_devolucao",
            Description: "Inicia o processo de devolução para um pedido elegível",
            Parameters: new
            {
                numeroPedido = new { type = "string" },
                motivo = new { type = "string" }
            }
        ),
        new Tool(
            Name: "transferir_humano",
            Description: "Transfere o atendimento para um agente humano quando necessário",
            Parameters: new
            {
                motivo = new { type = "string", description = "Motivo da transferência" },
                prioridade = new { type = "string", enum = new[] { "normal", "urgente" } }
            }
        ),
    };
}

// Loop de execução do agente (ReAct pattern)
public async Task<ConversaAtendimento> ExecutarTurnoAsync(
    string mensagemCliente,
    ConversaAtendimento conversa,
    CancellationToken ct)
{
    conversa.AdicionarMensagem("user", mensagemCliente);

    // Loop: modelo pensa → chama tool → processa resultado → responde
    for (int iteracao = 0; iteracao < 5; iteracao++) // max 5 iterações por turno
    {
        var resposta = await _llm.CompletarComToolsAsync(
            messages: conversa.Mensagens,
            tools: AtendimentoTools.Todas,
            ct);

        if (resposta.ToolCalls is null || !resposta.ToolCalls.Any())
        {
            // Modelo respondeu diretamente — fim do turno
            conversa.AdicionarMensagem("assistant", resposta.Conteudo);
            break;
        }

        // Executa as tool calls e adiciona resultados
        foreach (var toolCall in resposta.ToolCalls)
        {
            var resultado = await ExecutarToolAsync(toolCall, ct);
            conversa.AdicionarToolResult(toolCall.Id, resultado);
        }
    }

    return conversa;
}

private async Task<string> ExecutarToolAsync(ToolCall call, CancellationToken ct)
{
    return call.Name switch
    {
        "consultar_pedido" =>
            JsonSerializer.Serialize(
                await _pedidoService.ConsultarAsync(call.GetArg<string>("numeroPedido"), ct)),

        "registrar_reclamacao" =>
            JsonSerializer.Serialize(
                await _crmService.RegistrarAsync(
                    call.GetArg<string>("descricao"),
                    call.GetArg<string>("categoria"), ct)),

        "iniciar_devolucao" =>
            JsonSerializer.Serialize(
                await _logisticaService.IniciarDevolucaoAsync(
                    call.GetArg<string>("numeroPedido"),
                    call.GetArg<string>("motivo"), ct)),

        "transferir_humano" =>
            await TransferirParaHumanoAsync(
                call.GetArg<string>("motivo"),
                call.GetArg<string>("prioridade"), ct),

        _ => throw new InvalidOperationException($"Tool desconhecida: {call.Name}")
    };
}

Escalada para humano: o mecanismo mais importante

A qualidade de um chatbot de atendimento é medida não pelo que ele resolve sozinho, mas pela qualidade da escalada quando não consegue resolver. Escalada ruim significa cliente repetindo tudo para o atendente humano.

public class EscaladaService
{
    public async Task TransferirComContextoAsync(
        ConversaAtendimento conversa,
        string motivoEscalada,
        CancellationToken ct)
    {
        // Gera resumo da conversa para o atendente humano
        var resumo = await _llm.CompletarAsync($"""
            Resuma em 3 bullet points a conversa abaixo para um atendente humano
            que vai assumir o atendimento. Inclua: o problema do cliente, o que
            já foi tentado, e qual é o ponto de bloqueio.

            Conversa:
            {conversa.ParaTexto()}
            """, ct);

        // Cria ticket no CRM com contexto completo
        await _crm.CriarTicketAsync(new CrmTicket
        {
            ClienteId = conversa.ClienteId,
            Canal = "chatbot-ia",
            Prioridade = DeterminarPrioridade(conversa),
            ResumoIA = resumo,
            TranscricaoCompleta = conversa.ParaJson(),
            MotivoEscalada = motivoEscalada,
            SentimentoCliente = AnalisarSentimento(conversa)
        }, ct);
    }
}

Guardrails: o que o agente não pode fazer

Agentes com tools têm risco real de causar dano se não tiverem restrições claras:

// Regras obrigatórias no system prompt do agente
string systemPrompt = """
    Você é o assistente de atendimento da Acme.

    NUNCA faça sem confirmação explícita do cliente:
    - Cancelamento de pedidos
    - Devoluções acima de R$ 500
    - Alterações cadastrais

    NUNCA faça, mesmo com confirmação:
    - Reembolsos em dinheiro vivo (apenas crédito ou estorno)
    - Acesso a dados de outros clientes
    - Promessas de desconto ou compensação fora da política

    SEMPRE transfira para humano quando:
    - Cliente mencionar advogado, Procon, redes sociais ou imprensa
    - Cliente expressar raiva intensa por mais de 2 mensagens
    - A solicitação envolver valores acima de R$ 1.000
    - O cliente perguntar por nome ou código do atendente humano
    """;

Métricas para medir se está funcionando

As métricas que importam para um chatbot de atendimento não são NPS genérico — são métricas operacionais específicas:

• Taxa de resolução sem escalada: % de conversas concluídas sem transferir para humano. Meta razoável para o início: 40-50%. Maturos: 70%+.
• CSAT pós-chatbot: Satisfação do cliente após interação com o bot. Compare com CSAT do atendimento humano — se o bot tiver CSAT menor que 3/5, algo está errado no fluxo.
• Escalada com contexto completo: % das escaladas onde o atendente humano tinha o resumo da conversa. Deve ser 100%.
• Tempo médio de primeira resposta: Chatbot responde em segundos — isso deve reduzir significativamente o tempo de espera global.
• Taxa de re-abertura: % de conversas "resolvidas" pelo bot que o cliente reabre em menos de 24h. Alta taxa indica resoluções falsas.

Implementar IA no atendimento é um projeto de integração de sistemas, não apenas um projeto de IA. O sucesso não depende de qual LLM você usa — depende de quão bem o agente está conectado aos dados reais (pedidos, cadastro, políticas), de quão claros são os guardrails, e de quão transparente é a escalada para humano. Empresas que tratam isso como "instalar um chatbot" geralmente têm resultados ruins. Empresas que tratam como produto — com métricas, iteração e ownership claro — colhem os benefícios reais.