Automatize Análises e Extraia Insights

O que é e por que usar

A due diligence, seja financeira, legal ou operacional, é um processo intensivo em documentos. Um único projeto pode gerar centenas de páginas em PDFs, planilhas, apresentações e emails. Analisar manualmente esse volume de informação é lento, propenso a erros e dificulta a identificação de conexões cruzadas entre documentos. É aqui que a integração de relatórios de due diligence com o LlamaIndex se torna uma ferramenta estratégica.

O LlamaIndex é um framework projetado para conectar dados privados ou específicos de um domínio a modelos de linguagem grandes (LLMs). Em vez de fazer perguntas genéricas a um LLM, você usa o LlamaIndex para criar um índice inteligente do seu próprio conteúdo. Quando você faz uma pergunta, o sistema primeiro encontra os trechos mais relevantes nos seus documentos e só então os usa para gerar uma resposta precisa e contextualizada. Integrar isso ao n8n significa automatizar o fluxo completo: da coleta dos documentos brutos de diversas fontes (email, Google Drive, APIs) até a criação do índice e a geração automática de resumos, análises de risco e Q&A sob demanda.

O resultado é uma redução drástica no tempo de análise e um aumento na consistência e profundidade dos insights. Em vez de uma equipe gastar dias lendo, um fluxo automatizado pode, em horas, fornecer um resumo executivo, uma lista de inconsistências potenciais entre documentos, ou responder instantaneamente a perguntas específicas como “Quais são as obrigações contratuais da parte X mencionadas no anexo 3 e no laudo pericial?”.

Pré-requisitos

Para seguir este guia e implementar a integração, você precisará de:

Acesso ao n8n: Instância auto-hospedada ou conta n8n.cloud.
Conta de serviço em um provedor de LLM: Como OpenAI (para GPT-4/3.5), Anthropic (Claude), ou uma solução local como Ollama. Você precisará de uma chave de API.
Conhecimento básico de Python (opcional, mas útil): Para casos mais complexos onde o nó “Code” do n8n seja necessário para manipulações específicas de dados.
Documentos de due diligence em formato digital: PDFs, DOCX, XLSX, TXT, ou PPTX armazenados em um local acessível (pasta local, Google Drive, S3, etc.).
Ambiente Python configurado (para o nó “Execute Command”): Se optar por executar scripts Python diretamente no n8n, o servidor precisa ter as bibliotecas necessárias instaladas (llama-index, pypdf, etc.).

Exemplo Prático: Análise Automatizada de Due Diligence para Aquisição

Cenário concreto: Imagine que você é um analista de M&A (Fusões e Aquisições). Para avaliar uma empresa-alvo, você recebeu um pacote digital com 85 documentos: balanços patrimoniais (PDF), contratos de clientes (DOCX), due diligence legal (PDF), e uma planilha com métricas operacionais (XLSX). O prazo é curto e a equipe precisa de um panorama rápido e confiável.

O que será automatizado: Vamos criar um fluxo no n8n que, ao receber o link para uma pasta do Google Drive contendo os documentos, automaticamente:

Baixa todos os arquivos.
Processa o texto de cada um (ignorando elementos complexos como tabelas por enquanto).
Cria um índice vetorial usando LlamaIndex.
Executa um conjunto padrão de perguntas (prompts) sobre os documentos.
Consolida as respostas em um relatório único em formato Markdown e o envia por email para a equipe.

Resultado esperado: Em menos de uma hora de processamento automatizado, a equipe recebe um email com um documento contendo: 1) Um resumo executivo da due diligence; 2) Uma lista dos 5 principais riscos financeiros identificados; 3) Um resumo das cláusulas contratuais mais restritivas; 4) Quaisquer inconsistências de datas ou valores encontradas entre os documentos. Isso fornece um ponto de partida direcionado para a análise humana profunda.

Configuração Passo a Passo

Vamos construir um fluxo no n8n que utiliza o nó “Execute Command” para rodar um script Python que emprega o LlamaIndex. Esta abordagem oferece máxima flexibilidade.

Passo 1: Estrutura do Fluxo no n8n

Crie um novo fluxo no n8n e adicione os seguintes nós na ordem:

Nó “Schedule Trigger”: Configure para disparar manualmente ou em uma agenda (ex: diariamente às 8h).
Nó “Google Drive”: Configure para listar todos os arquivos em uma pasta específica. Use o método “Get All Files” em “Folder to Get Files From”. Certifique-se de autenticar com o OAuth2 do Google.
Nó “Google Drive” (novo): Conectado ao anterior. Configure para “Download” cada arquivo. No campo “Binary Property”, defina como `data`. Este nó passará adiante cada arquivo e seu conteúdo binário.
Nó “Set”: Use para estruturar os dados para o script Python. Crie dois campos:
- `file_name`: `{{ $json.name }}`
- `file_content`: `{{ $json.data }}` (isso será o binário do arquivo)
Nó “Execute Command”: O núcleo do processo. Veja a configuração detalhada abaixo.
Nó “Code” (JavaScript/Node.js): Para processar a saída do script Python (que será um texto JSON) e convertê-la em um formato utilizável pelo n8n.
Nó “Markdown”: Para formatar as respostas do LLM em um relatório bem estruturado.
Nó “Email Send” (SMTP ou serviço como SendGrid): Para enviar o relatório final.

Passo 2: Configuração do Nó “Execute Command”

Este nó executará um script Python. No campo “Command”, insira `python3`. No campo “Arguments”, adicione `-c` e então cole o script Python completo no campo ao lado. Abaixo está um exemplo simplificado que você deve adaptar.

import sys, json, os, base64, tempfile
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext, load_index_from_storage
from llama_index.core import Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# 1. Receber dados do n8n (via STDIN)
input_data = sys.stdin.read()
try:
    items = json.loads(input_data)
except:
    print(json.dumps({"error": "Invalid JSON input from n8n"}))
    sys.exit(1)

# 2. Configurar LLM e Embeddings (USE SUA CHAVE AQUI ou variável de ambiente)
os.environ["OPENAI_API_KEY"] = "sua-chave-api-aqui"
Settings.llm = OpenAI(model="gpt-3.5-turbo", temperature=0.1)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# 3. Salvar arquivos binários do n8n em arquivos temporários
temp_dir = tempfile.mkdtemp()
documents = []
for item in items:
    file_name = item["file_name"]
    file_content_b64 = item["file_content"]  # n8n envia binário como base64
    # Decodificar do formato do n8n (é um objeto com data)
    if isinstance(file_content_b64, dict) and 'data' in file_content_b64:
        file_data = base64.b64decode(file_content_b64['data'])
    else:
        # Fallback: tratar como string base64 direta
        file_data = base64.b64decode(file_content_b64)
    
    temp_file_path = os.path.join(temp_dir, file_name)
    with open(temp_file_path, 'wb') as f:
        f.write(file_data)
    documents.append(temp_file_path)

# 4. Carregar documentos e criar índice
try:
    docs = SimpleDirectoryReader(input_files=documents).load_data()
    index = VectorStoreIndex.from_documents(docs)
    
    # 5. Criar motor de consulta e fazer perguntas
    query_engine = index.as_query_engine(similarity_top_k=3)
    
    queries = [
        "Gere um resumo executivo conciso (máximo 300 palavras) sobre o estado geral da empresa-alvo com base em todos os documentos.",
        "Liste os 5 principais riscos financeiros ou operacionais identificáveis.",
        "Resuma as cláusulas contratuais mais importantes ou restritivas encontradas."
    ]
    
    answers = {}
    for q in queries:
        response = query_engine.query(q)
        answers[q] = str(response)
    
    # 6. Limpar arquivos temporários
    for f in documents:
        try:
            os.remove(f)
    except:
        pass
    os.rmdir(temp_dir)
    
    # 7. Enviar resultados de volta para o n8n
    print(json.dumps({"analysis": answers}))
    
except Exception as e:
    print(json.dumps({"error": f"Failed during processing: {str(e)}"}))
    sys.exit(1)

Parâmetros do nó:

Command: `python3`
Arguments: `-c`
STDIN Input: `{{ $json }}` (Isso passa todo o item atual, contendo file_name e file_content, para o script).
Working Directory: Deixe em branco ou defina um caminho onde o Python esteja configurado.

Passo 3: Processar a Resposta e Finalizar

O nó “Execute Command” retornará uma string JSON. Use um nó “Code” (JavaScript) para analisá-la:


// Código para o nó "Code" (JavaScript)
const input = $input.first();
const result = input.json;

if (result.error) {
  throw new Error(`Erro no script Python: ${result.error}`);
}

// Supondo que 'analysis' é um objeto onde a chave é a pergunta e o valor a resposta
const analysis = result.analysis;

// Formatar para passar para o próximo nó
const markdownContent = `# Relatório de Due Diligence Automatizado\n\n`;
for (const [question, answer] of Object.entries(analysis)) {
  markdownContent += `## ${question}\n${answer}\n\n---\n\n`;
}

return [{ json: { report_markdown: markdownContent } }];

Conecte a saída deste nó ao nó “Markdown” (defina o campo como `{{ $json.report_markdown }}`) e depois ao nó de email para envio final.

Dicas e Variações

Use Armazenamento Persistente: Em vez de criar o índice a cada execução, use `index.storage_context.persist(persist_dir=”./storage”)` para salvá-lo. Na próxima execução, verifique se o diretório existe e use `load_index_from_storage` para carregar o índice antigo e apenas adicionar novos documentos, economizando custos com embeddings.
Incremente com Metadados: Ao criar o índice, você pode adicionar metadados aos nós (documentos), como `document_type: “contrato”`, `year: 2023`. Isso permite filtrar consultas: “Quais riscos são mencionados apenas em contratos?”.
Combine com Webhook: Substitua o trigger agendado por um Webhook. Assim, você pode enviar documentos para análise via API (ex: de um portal do cliente) e receber o relatório de volta automaticamente.
Para Documentos Complexos (Tabelas): Use o reader `pymupdf` para PDFs ou a biblioteca `llama-index-readers-file` com o `PandasExcelReader` para extrair tabelas de planilhas como DataFrames, que podem ser incluídos no índice.
Controle de Custos: Para muitos documentos, o custo de criar embeddings pode ser alto. Considere usar embeddings locais (via `HuggingFaceEmbedding`) ou dividir a indexação em lotes, processando apenas documentos novos ou alterados.

Erros Comuns e Como Evitá-los

Erro: “ModuleNotFoundError: No module named ‘llama_index'”: O Python no servidor n8n não tem as bibliotecas instaladas. Solução: Instale-as via SSH no servidor (`pip install llama-index-core llama-index-readers-file llama-index-llms-openai pypdf`) ou use contêineres Docker com o n8n que já incluam o Python e suas dependências.
Erro: Timeout no nó “Execute Command”: Indexar muitos documentos pode levar minutos. Solução: Aumente o “Timeout” nas configurações do nó (padrão é 3600 segundos). Para lotes muito grandes, divida o processo: um fluxo cria e persiste o índice, outro fluxo faz as consultas.
Problema: Respostas Genéricas ou Hallucinations: O LLM está inventando informações. Solução: Reduza a `temperature` para 0.1 ou 0. Configure o `similarity_top_k` no query engine para um valor maior (ex: 5) para fornecer mais contexto. Sempre inclua a instrução “Baseie sua resposta estritamente nos documentos fornecidos” no prompt.
Erro: Falha ao Decodificar Arquivo Binário: O formato do dado binário do n8n pode variar. Solução: Use o código de decodificação robusto mostrado no exemplo, que lida com o objeto `{ data: ‘…’ }` que o n8n envia.
Problema de Token Limit (Contexto): Documentos muito longos excedem o limite de contexto do LLM. Solução: O LlamaIndex já divide documentos em “chunks”. Ajuste os parâmetros `chunk_size` e `chunk_overlap` nas `Settings` do LlamaIndex para otimizar a retenção de contexto.

Próximos Passos

Agora que você compreende a estrutura básica, é hora de evoluir sua automação:

Teste com um Conjunto Pequeno: Comece com 2-3 documentos PDF em uma pasta do Google Drive. Execute o fluxo manualmente e valide o relatório gerado.
Implemente Persistência do Índice: Modifique o script Python para verificar a existência de um índice salvo. Isso reduzirá o tempo de execução e os custos de API nas próximas análises.
Crie um Painel Interativo: Use os nós “Webhook” (para receber perguntas) e “HTTP Request” (para responder) para criar uma API simples. Integre-a a um chatbot interno (como no Slack via nó “Slack”) onde analistas possam fazer perguntas em tempo real sobre a base documental indexada.
Explore Outros LLMs: Substitua `OpenAI` no script por `Anthropic` (Claude) ou `Ollama` (para modelos locais como Llama 3) para maior controle de custos ou privacidade.

A integração de due diligence com LlamaIndex via n8n transforma um processo manual e árduo em uma vantagem competitiva. Comece pequeno, itere rapidamente e escale a automação conforme a confiança no sistema cresce.

Integre relatórios de due diligence com LlamaIndex