Prompts prontos para criar agentes de IA com LangChain no n8n

Criando Agentes de IA no n8n com LangChain: Prompts Prontos para Automação

Você quer criar agentes de IA no n8n usando LangChain sem escrever uma linha de código? Use prompts prontos para gerar fluxos de automação que respondem perguntas, resumem textos, extraem dados ou até atendem clientes automaticamente. Basta conectar nós do n8n com nós do LangChain e alimentar com prompts específicos para cada tarefa.

Neste guia, você vai aprender desde a configuração inicial até fluxos avançados com 5 prompts prontos. Tudo sem programação, com nós visuais e expressões JavaScript simples. O LangChain aqui age como "cola" entre o n8n e modelos de IA como ChatGPT ou Gemini, transformando tarefas manuais em automação inteligente.

O que é LangChain e por que usá-lo no n8n para criar agentes de IA

LangChain é uma biblioteca de código aberto que padroniza a forma de conectar modelos de linguagem (LLMs) a fontes de dados e sistemas externos. No n8n, ele permite criar agentes de IA sem escrever código, usando nós visuais para definir prompts, cadeias de raciocínio e integrações. Com LangChain, você constrói fluxos que vão além de um chatbot simples: eles podem extrair dados de APIs, tomar decisões ou até usar múltiplos modelos em sequência.

A integração com n8n elimina a necessidade de saber Python ou JavaScript. Você usa nós como "LangChain Chain", "LLM" e "Prompt" para orquestrar tarefas complexas. Segundo a documentação oficial, LangChain é ideal para LLMOps — operações de modelos de linguagem em produção — e funciona com mais de 50 integrações nativas.

Saiba mais sobre LangChain na documentação oficial.

Contexto técnico: LangChain não é um LLM, mas uma "cola" que une LLMs a ferramentas. Por exemplo, você pode criar um agente que primeiro pesquisa dados no Google Sheets, depois usa um LLM para analisar os dados e, por fim, envia um relatório via e-mail — tudo em um único fluxo no n8n.

Requisitos mínimos: o que você precisa antes de começar

Para criar agentes de IA no n8n com LangChain, você precisa de:

Dica: Para modelos gratuitos, use o Hugging Face, mas lembre-se de que pode haver limitações de taxa de uso. O LangChain suporta integrações com modelos open-source como LLama 2.

Configurando o ambiente: n8n e LangChain do zero

Siga este passo a passo para ter o n8n e o LangChain funcionando em 10 minutos, seja na nuvem ou localmente:

1. Crie sua conta no n8n

   Se for usar a nuvem, acesse n8n.cloud e crie um projeto. Se preferir self-hosted, siga o guia oficial de instalação com Docker.

   Resultado esperado: Acesso ao editor visual do n8n com nós disponíveis.

2. Instale o nó LangChain no n8n

   No editor, clique em "Nodes" > "Instalar nó comunitário" e procure por LangChain. Instale a versão mais recente. Se não aparecer, use o nó "Function" para JavaScript como alternativa temporária.

   Resultado esperado: Nós como "LangChain Chain" e "LLM" aparecem na lista de nós disponíveis.

3. Configure as credenciais de API

   Vá em "Credenciais" > "Novo" > "LangChain" e adicione suas chaves de API (OpenAI, Google AI ou outra). Teste a conexão clicando em "Testar conexão".

   Resultado esperado: Status "Conexão bem-sucedida" e nós prontos para usar modelos de IA.

4. Prepare os nós básicos para automação

   Crie um fluxo com estes nós iniciais: "Webhook" (para receber dados), "LLM" (LangChain), "Set" (para salvar respostas) e "HTTP Request" (para enviar dados). Salve o fluxo.

   Resultado esperado: Fluxo básico pronto para ser expandido com prompts e lógica.

Curiosidade técnica: Se você usar o nó "LangChain Chain" com o modelo ChatGPT-4o, cada chamada consome cerca de 0,002 USD. Em fluxos longos, use caching (cache de respostas) para reduzir custos. No n8n, isso pode ser feito com nós "Set" + "IF" para armazenar e reutilizar respostas.

Prompts prontos para criar seu primeiro agente de IA no n8n

Veja 5 fluxos prontos para copiar e colar no seu n8n. Cada um usa nós específicos e prompts otimizados para tarefas comuns. Basta substituir as variáveis (como {{ $json.texto }}) pelos seus dados.

1. Chatbot simples com memória de contexto

Este fluxo cria um chatbot que lembra o histórico da conversa e responde de forma coerente. Ideal para atendimento ao cliente ou suporte interno.

  Você é um assistente útil. Responda apenas ao que foi perguntado.
  Histórico: {{ $node["Set"].json["contexto"] }}
  Pergunta: {{ $json.mensagem }}
  Resposta:
  
</td>

  return {
    json: {
      resposta: $node["Set"].json["resposta"],
      contexto: $node["Set"].json["contexto"]
    }
  };
  
</td>

Como testar: Envie um POST para https://SEU-N8N.com/webhook/chatbot com o corpo {"mensagem": "Qual é o preço do seu produto?"}. O chatbot responderá e lembrará da conversa.

Dica: Para evitar erros de contexto muito longo, limite o histórico a 5 interações usando slice() no nó "Set". Por exemplo: {{ $node["Set"].json["contexto"].slice(-5) }}.

2. Resumo automático de textos longos

Este fluxo extrai texto de uma URL ou arquivo e gera um resumo em 3 sentenças. Perfeito para análise de e-mails, artigos ou relatórios.

  Resuma o seguinte texto em 3 sentenças:
  ---
  {{ $node["Set"].json["texto_completo"] }}
  ---
  Resumo:
  
</td>

Como testar: Envie um POST para https://SEU-N8N.com/webhook/resumir com o corpo {"url": "https://example.com/artigo"}. O fluxo retornará o resumo em 3 sentenças.

Curiosidade técnica: Se o texto for muito longo (acima de 10.000 caracteres), use o nó "Split In Batches" para dividir o texto em partes menores antes de enviar ao LLM. Isso evita erros de token limit.

3. Extração de dados de e-mails (ex: pedidos)

Este fluxo lê um e-mail (via IMAP), extrai informações como nome do cliente, produto e valor, e salva em um Google Sheets ou banco de dados.

  const emailBody = $node["IMAP Email"].json["body"];
  const extracted = {
    nome: emailBody.match(/Nome: (.*)/)[1],
    produto: emailBody.match(/Produto: (.*)/)[1],
    valor: emailBody.match(/Valor: R\$ (.*)/)[1]
  };
  return { json: extracted };
  
</td>

  Valide os dados extraídos e corrija erros de formatação:
  Nome: {{ $node["Function"].json["nome"] }}
  Produto: {{ $node["Function"].json["produto"] }}
  Valor: {{ $node["Function"].json["valor"] }}
  Formato esperado: { "nome": "string", "produto": "string", "valor": "number" }
  Saída JSON:
  
</td>

Como testar: Envie um e-mail para sua conta com assunto "Novo Pedido" e corpo no formato: Nome: João Silva\nProduto: Notebook X1\nValor: R$ 3.500. O fluxo extrairá e salvará os dados na planilha.

Dica: Para e-mails em HTML, use o nó "HTML Extract" antes do "Function" para extrair apenas o texto relevante. Evite erros de parsing com expressões regulares robustas.

4. Classificação automática de leads (bom/médio/ruim)

Este fluxo lê dados de leads (nome, e-mail, mensagem) e classifica-os como "Bom", "Médio" ou "Ruim" com base em critérios como intenção de compra e urgência.

  Classifique o seguinte lead como "Bom", "Médio" ou "Ruim" com base nestes critérios:
  - Intenção de compra: alta/média/baixa
  - Urgência: sim/não
  - Recursos mencionados: produto/serviço/nenhum
  ---
  Nome: {{ $node["Set"].json["lead"].nome }}
  E-mail: {{ $node["Set"].json["lead"].email }}
  Mensagem: {{ $node["Set"].json["lead"].mensagem }}
  ---
  Classificação:
  
</td>

Como testar: Envie um POST para https://SEU-N8N.com/webhook/classificar-lead com o corpo {"nome": "Maria Oliveira", "email": "maria@email.com", "mensagem": "Preciso de um orçamento para 5 computadores urgente!"}. O fluxo classificará o lead e enviará para o CRM.

Curiosidade técnica: Para melhorar a precisão, use o nó "LLM" com temperatura baixa (0.1) para respostas mais consistentes. Evite classificações aleatórias em fluxos críticos.

5. Geração de relatórios automáticos (PDF ou e-mail)

Este fluxo coleta dados de múltiplas fontes (planilhas, APIs), gera um relatório estruturado e envia por e-mail ou salva como PDF.

  const vendas = $node["Google Sheets"].json["data"];
  const estoque = $node["HTTP Request"].json["body"];
  const relatorio = {
    data: new Date().toISOString().split('T')[0],
    vendas: vendas.reduce((acc, item) => acc + item[3], 0),
    produtos_baixo_estoque: estoque.filter(item => item.quantidade < 10).length
  };
  return { json: relatorio };
  
</td>

  Gere um relatório profissional em português com os dados abaixo:
  ---
  Data: {{ $node["Function"].json["data"] }}
  Vendas totais: R$ {{ $node["Function"].json["vendas"] }}
  Produtos com estoque baixo: {{ $node["Function"].json["produtos_baixo_estoque"] }}
  ---
  Inclua insights de tendências e recomendações.
  Formato: Markdown.
  
</td>

Como testar: Configure o "Schedule Trigger" para rodar imediatamente e verifique se o e-mail é enviado com o relatório. Substitua as fontes de dados pelas suas.

Dica: Para gerar PDFs, use o nó "PDF" após o "Set" com o relatório em HTML. Exemplo de configuração: {{ $node["Set"].json["relatorio"] }} no campo "HTML".

Automatizando tarefas com LangChain: exemplos práticos para negócios

Use LangChain no n8n para resolver problemas reais de negócios com automação inteligente. Os casos abaixo mostram como aplicar prompts prontos para reduzir tempo manual em 80% e aumentar precisão em tarefas repetitivas.

Os exemplos cobrem atendimento ao cliente, análise de dados e geração de relatórios — tudo sem código. Basta adaptar os nós e prompts para seu contexto.

Atendimento ao cliente com IA: reduzindo 90% das respostas manuais

Crie um sistema de atendimento que responde 90% das dúvidas recorrentes com IA, encaminhando apenas casos complexos para humanos. Ideal para lojas virtuais, SaaS ou suporte técnico.

Dica: Para lojas virtuais, integre o fluxo com SaaS com IA para personalizar respostas com histórico de compras do cliente. Por exemplo: "Olá [Nome], seu último pedido foi [Produto X] — precisa de ajuda com ele?".

Análise de dados: transformando informações brutas em insights

Automatize a análise de grandes volumes de dados com LangChain + n8n. Os fluxos abaixo processam dados de múltiplas fontes e entregam insights acionáveis sem intervenção humana.

Curiosidade técnica: Para analisar grandes volumes de texto (ex: transcrições de chamadas), divida o conteúdo em chunks de 4.000 tokens usando o nó "Split In Batches" antes de enviar ao LangChain. Isso evita erros de "context too long" e melhora a precisão.

Geração de relatórios: do CSV ao PDF em 2 minutos

Automatize a criação de relatórios personalizados com dados de múltiplas fontes. Os fluxos abaixo geram relatórios diários, semanais ou mensais com formatação profissional.

Exemplo prático: Para gerar um relatório de vendas diário:

1. Use "Schedule Trigger" para rodar às 8h.
2. Baixe dados de vendas do Google Sheets e estoque da API do ERP.
3. Use LangChain para gerar um resumo executivo com insights (ex: "Vendas cresceram 15% vs. ontem, mas o estoque de X produto está baixo").
4. Crie um PDF com o nó "PDF" ou envie por e-mail com o nó "Email".

Dica: Para relatórios em Markdown, use o nó "Set" para formatar o texto e o nó "PDF" com a opção "Convert HTML to PDF". Exemplo de prompt para LangChain:

Gere um relatório em Markdown com os seguintes dados: --- Vendas totais: R$ 50.000 Top 3 produtos: Notebook (R$ 20.000), Mouse (R$ 10.000), Teclado (R$ 5.000) --- Inclua insights como "O produto X teve um aumento de 30% em vendas".

Erros comuns e como resolvê-los no n8n com LangChain

Problemas como timeouts, erros de API ou JSON mal formatado são comuns em fluxos com IA. Veja a lista de erros frequentes e soluções práticas para resolvê-los rápido.

Use a abordagem de vibe coding para iterar rapidamente: ajuste nós, teste e repita até o fluxo funcionar. LangChain + n8n permite isso sem reiniciar servidores.

Lista de erros e soluções

Dica para vibe coding: Se o fluxo não funcionar, isole o problema testando cada nó individualmente. Por exemplo:

1. Teste o nó "Webhook" enviando um POST manual com curl.
2. Verifique se os dados chegam corretamente no nó "Set".
3. Substitua o nó "LangChain Chain" por um nó "Function" que retorne um texto fixo (ex: return { json: { resposta: "Teste" } };).
4. Se funcionar, o problema está no prompt ou na configuração do LLM.

Curiosidade técnica: Se você estiver usando o nó "LangChain Chain" com múltiplos modelos (ex: ChatGPT + Llama 2), adicione um nó "Switch" para alternar entre eles com base na tarefa. Exemplo: use ChatGPT para tarefas criativas e Llama 2 para tarefas técnicas (menor custo).

Alternativas ao LangChain: quando usar e quando não usar no n8n

LangChain não é a única opção para integrar IA no n8n. Veja quando usar LangChain, LangGraph, nós nativos do n8n ou outras ferramentas — e quando evitar.

A escolha depende de complexidade, custo e curva de aprendizado. Para tarefas simples, nós nativos do n8n podem ser suficientes. Para fluxos complexos, LangChain ou LangGraph são melhores.

Comparação: LangChain vs. LangGraph vs. n8n nativo

Quando usar LangChain:

• Você precisa de agentes de IA com múltiplos passos (ex: "Buscar dados → Analisar → Enviar relatório").
• Quer integrar múltiplas fontes de dados (Google Sheets, APIs, bancos de dados).
• Precisa de memória de contexto (ex: chatbots que lembram conversas anteriores).
• Não quer escrever código, mas precisa de flexibilidade (prompts personalizados, loops, condicionais).

Quando NÃO usar LangChain:

• Sua tarefa é simples (ex: resumir um texto ou classificar sentimentos). Use nós nativos do n8n ou "Function".
• Você precisa de baixo custo e está disposto a usar modelos open-source (ex: Llama 2). Neste caso, LangGraph ou nós nativos são melhores.
• Não tem orçamento para custos de API (LangChain usa LLMs pagos como ChatGPT ou Gemini).
• Prefere controle total sobre a lógica (LangChain é uma camada de abstração que pode esconder detalhes).

Quando usar LangGraph:

• Você precisa de lógica complexa (ex: loops, condicionais aninhadas, uso de múltiplos modelos em sequência).
• Quer rodar modelos localmente (ex: LLama 2) sem depender de APIs pagas.
• Tem familiaridade com Python e prefere programar a lógica em vez de usar nós visuais.

Quando usar nós nativos do n8n:

• Sua tarefa é pontual (ex: enviar um e-mail com um resumo gerado por IA).
• Não quer depender de custos de API ou limitações de tokens.
• Prefere simplicidade (sem prompts, sem nós adicionais).

Dica: Para tarefas que misturam IA e automação tradicional, use uma combinação de nós. Exemplo:

1. Use nós nativos do n8n para coletar dados (ex: Google Sheets, IMAP).
2. Use LangChain para processar os dados com IA (ex: classificar, resumir).
3. Use nós nativos do n8n para enviar o resultado (ex: e-mail, Slack, planilha).

Curiosidade técnica: LangGraph é ideal para fluxos que exigem estado (ex: "Se o usuário perguntar X, faça Y; senão, faça Z"). Enquanto LangChain foca em cadeias de raciocínio lineares, LangGraph permite loops e condicionais complexas.

Leia mais: Para entender como a API do ChatGPT funciona por trás dos panos, confira nosso artigo API do ChatGPT: Guia Prático para Automação.

Dicas avançadas: otimizando seus agentes de IA para produção

Leve seus agentes de IA do n8n para produção com otimizações de performance, caching, logs e monitoramento. Aqui você encontra boas práticas de LLMOps e EEAT (Experience, Expertise, Authoritativeness, Trustworthiness) aplicadas a fluxos de automação.

Essas dicas são usadas por quem já usa LangChain + n8n em escala para reduzir custos em 40% e aumentar a confiabilidade dos fluxos.

Performance: reduzindo custos e tempo de execução

Otimize seus fluxos para rodar mais rápido e gastar menos com APIs de IA.

Exemplo de caching: Para um chatbot que lembra histórico:

// Nó "Set" para armazenar cache
const cache = $node["Cache"].json["respostas"] || [];

// Verifica se a pergunta já foi respondida hoje
const perguntaHoje = cache.find(item =>
  item.pergunta === $json.mensagem &&
  new Date(item.data).toDateString() === new Date().toDateString()
);

if (perguntaHoje) {
  return { json: { resposta: perguntaHoje.resposta } };
}

// Se não estiver em cache, chama o LLM
return { json: { resposta: $node["LLM"].json["response"] } };

Dica: Para caching em escala, use o nó "Cache" do n8n ou um banco de dados como Redis. Exemplo de configuração no nó "Cache":

• Chave: {{ $json.mensagem }}
• Valor: {{ $node["LLM"].json["response"] }}
• Tempo de expiração: 24h

Logs e monitoramento: mantendo seus fluxos saudáveis

Monitore seus agentes de IA para detectar problemas antes que eles afetem seus usuários. Use logs detalhados e alertas para manter a confiabilidade.

Exemplo de log no Google Sheets:

1. Crie uma planilha com as colunas: Timestamp, Fluxo, Input, Output, Status, Custo.
2. No final do fluxo, use um nó "Google Sheets" para adicionar uma linha com os dados:

{
  "Timestamp": new Date().toISOString(),
  "Fluxo": "Chatbot",
  "Input": $json.mensagem,
  "Output": $node["LLM"].json["response"],
  "Status": "Sucesso",
  "Custo": 0.002 // Custo da chamada ao LLM
}

Curiosidade técnica: Para monitorar LLMOps em produção, use ferramentas como Langfuse ou Phoenix. Elas permitem rastrear prompts, respostas, erros e métricas de desempenho em tempo real.

Dica para EEAT: Se seu agente de IA interage com clientes, adicione nós que garantam transparência e confiabilidade:

• Use nós "Set" para armazenar a fonte das informações (ex: "Resposta baseada no FAQ da empresa, atualizado em 2024-10-01").
• Adicione nós "Function" para validar dados antes de enviar ao cliente (ex: verificar se um preço está atualizado).
• Inclua nós "Email" ou "Slack" para notificar o time quando o agente fizer uma afirmação crítica (ex: "O estoque do produto X está esgotado").

Segurança e conformidade: protegendo seus dados

Garanta que seus fluxos de IA estejam em conformidade com LGPD, GDPR e outras regulamentações. Use boas práticas para proteger dados sensíveis.

Exemplo de anonimização:

// Nó "Function" para mascarar CPF
const cpf = $json.cpf;
const mascarado = cpf.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, "$1.***.***-$4");
return { json: { cpf: mascarado, nome: $json.nome } };

Dica: Para fluxos que lidam com dados de clientes, use o nó "Data Transformation" do n8n para aplicar regras de conformidade automaticamente. Exemplo:

• Remova dados após 30 dias (LGPD).
• Notifique o cliente quando dados forem acessados (GDPR).

Curiosidade técnica: Se você usa o nó "LangChain Chain" com modelos open-source (ex: LLama 2), armazene os modelos em um servidor local ou em uma nuvem privada (ex: AWS EC2) para evitar vazamento de dados para terceiros.

Perguntas frequentes sobre Prompts prontos para criar agentes de IA com LangChain dentro do n8n

O que é LangChain e por que usar no n8n?

LangChain é uma biblioteca que conecta modelos de linguagem a sistemas externos, permitindo criar agentes de IA sem código. No n8n, ele possibilita fluxos avançados como chatbots com memória, extração de dados e tomada de decisões automáticas, tudo com nós visuais.

Preciso saber programar para usar LangChain no n8n?

Não! O LangChain no n8n usa nós visuais e prompts prontos, eliminando a necessidade de programação. Basta configurar nós como 'LangChain Chain' e 'LLM' com prompts específicos para cada tarefa, como resumir textos ou classificar leads.

Quais são os nós essenciais do n8n para criar um agente com LangChain?

Os nós principais são: 'Webhook' (para receber dados), 'LangChain Chain' (para processar com IA), 'Set' (para salvar respostas), 'IF' (para lógica condicional) e 'Respond to Webhook' (para enviar respostas). Outros nós como 'HTTP Request' e 'Google Sheets' são úteis para integrações.

Como conectar a API do ChatGPT no n8n com LangChain?

Adicione suas credenciais do ChatGPT no nó 'Credenciais' do n8n. Depois, use o nó 'LangChain Chain' com o modelo 'gpt-4o' ou 'gpt-4o-mini'. Configure o prompt no campo específico e teste a conexão clicando em 'Testar conexão' no nó de credenciais.

Posso usar LangChain com modelos de IA gratuitos no n8n?

Sim! Você pode usar modelos open-source como Llama 2 via Hugging Face ou modelos gratuitos do Google AI (Gemini). Para isso, configure as credenciais da plataforma desejada no nó 'Credenciais' do n8n e selecione o modelo no nó 'LangChain Chain'.

Como estruturar um fluxo de automação com LangChain no n8n?

Comece com um 'Webhook' ou 'Schedule Trigger' para iniciar o fluxo. Use nós 'Set' para preparar dados, 'LangChain Chain' para processar com IA, e nós como 'Email' ou 'Google Sheets' para enviar/armazenar resultados. Teste cada nó individualmente antes de conectá-los.

Quais são os erros comuns ao usar LangChain no n8n?

Os erros mais comuns são: timeouts (aumente o limite no nó 'LLM'), JSON mal formatado (use nós 'Function' para validar), e limites de taxa (adicione nós 'Wait' entre chamadas). Sempre teste a conexão das credenciais e isole nós problemáticos para debugar.

LangChain funciona com outros modelos além do ChatGPT e Gemini?

Sim! LangChain suporta mais de 50 integrações, incluindo modelos locais como Llama 2, Mistral e modelos do Hugging Face. Basta configurar as credenciais da plataforma desejada no nó 'Credenciais' do n8n e selecionar o modelo no nó 'LangChain Chain'.

Agentes de IA sem código: o futuro da automação está aqui

Criar agentes de IA no n8n com LangChain é mais simples do que parece: com nós visuais, prompts prontos e integrações práticas, você transforma tarefas manuais em automação inteligente em minutos. Desde chatbots com memória até extração de dados e classificação de leads, as possibilidades são infinitas — e tudo sem escrever uma linha de código.

• Sem programação: Use nós visuais e prompts prontos para criar agentes em minutos.
• Custo controlado: Otimize com caching, modelos menores e divisão de tarefas para reduzir gastos.
• Casos reais: Aplique em atendimento ao cliente, análise de dados, geração de relatórios e muito mais.
• Produção segura: Monitore, logue e proteja seus fluxos com boas práticas de LLMOps e conformidade.

Pronto para transformar sua rotina? Explore a categoria Automação com IA no automacao.art.br e descubra mais tutoriais, ferramentas e dicas para levar seus fluxos ao próximo nível!

Quer mais sobre o assunto? Veja todos os artigos de APIs & Dev ou a lista completa de artigos.