TL;DR: O artigo detalha quatro arquiteturas de RAG (Retrieval-Augmented Generation) – Prep, Vanilla, Adaptive e Hybrid – e como implementá-las no Make, usando módulos HTTP e integrações externas para aprimorar respostas de LLMs com dados externos. A escolha da arquitetura depende da complexidade do problema, da necessidade de busca externa e da variedade de fontes de dados. A implementação no Make exige o uso de APIs externas e serviços de apoio para processamento de texto e roteamento de consultas.

Takeaways:

• RAG combina LLMs com bases de conhecimento externas para respostas mais precisas e contextualizadas.
• O Make pode ser usado para orquestrar fluxos de RAG, integrando APIs como OpenAI, Pinecone e Supabase.
• Arquiteturas Adaptive e Hybrid RAG otimizam o processo, decidindo dinamicamente se a busca externa é necessária ou consultando múltiplas fontes de dados.
• A preparação dos dados, incluindo chunking e geração de embeddings, é crucial para o bom funcionamento das arquiteturas RAG.
• A escolha da arquitetura RAG depende dos requisitos específicos do projeto, equilibrando simplicidade, eficiência e acesso a diversas fontes de dados.

Arquiteturas Práticas de RAG (Retrieval-Augmented Generation) e Implementação no Make

Introdução

Retrieval-Augmented Generation (RAG) é uma abordagem que une modelos de linguagem de grande escala (LLMs) com bases de conhecimento externas, permitindo respostas mais precisas e contextualizadas. Em vez de depender apenas da capacidade preditiva do modelo, a RAG recorre a dados armazenados em vetores, bancos relacionais ou APIs para enriquecer o conteúdo gerado. Essa sinergia amplia o escopo de aplicação em cenários que exigem informações atualizadas ou domínio específico.

A imagem inicial destaca quatro arquiteturas de RAG—Prep, Vanilla, Adaptive e Hybrid—e mostra como o Make (antigo Integromat) pode orquestrar esses fluxos usando módulos HTTP e integrações externas. Cada arquitetura atende a um nível distinto de complexidade e flexibilidade, desde a preparação dos dados até consultas dinâmicas em múltiplas fontes. O entendimento dessas abordagens viabiliza soluções de IA que respondem com precisão e agilidade.

Neste artigo, detalharemos passo a passo cada arquitetura, mostrando os componentes principais, técnicas envolvidas e exemplos práticos de prompts e integrações. Abordaremos também a configuração geral no Make, as ferramentas externas mais comuns e as considerações finais para adoção e evolução desses fluxos em projetos reais.

Preparação de Dados: Adicionando Arquivos do Google Drive ao Pinecone

A primeira etapa essencial para qualquer arquitetura RAG é preparar os dados que serão consultados pelo modelo. No fluxo “Prep”, vídeos, documentos ou PDFs armazenados no Google Drive são monitorados e processados automaticamente. Usamos o módulo Google Drive → Watch Files para detectar criação ou modificação de arquivos, seguido do download e extração de texto, divisão em chunks e geração de embeddings que serão salvos no Pinecone.

Em um cenário prático, ao configurar o Make, o gatilho “Google Drive → Watch Files” ativa o fluxo quando um arquivo é criado ou atualizado. Em seguida, o módulo “Download a File” recupera o documento e uma chamada HTTP ao Read API de ferramentas como Docparser (https://docparser.com/) ou Mindee (https://www.mindee.com/) extrai o texto. Um componente de chunking (por exemplo, hospedado em Cloudflare Workers) segmenta o conteúdo em pedaços menores, e a API da OpenAI gera embeddings que são armazenados no Pinecone via seu endpoint de vetores.

Esse processo assegura que os dados estejam estruturados para buscas vetoriais eficientes. Os itens-chave incluem monitoramento contínuo de arquivos, extração e divisão de texto em chunks e a geração de embeddings para indexação. Com isso, garantimos uma base robusta para consultas posteriores em arquiteturas RAG.

Vanilla RAG: Utilizando a Pergunta do Usuário Diretamente

Na arquitetura Vanilla RAG, a pergunta do usuário alimenta diretamente o mecanismo de busca vetorial. Esse fluxo simples recebe o input via webhook, gera embeddings da pergunta e busca no Pinecone pelos documentos mais relevantes antes de compor o prompt final para o modelo da OpenAI. A resposta é então devolvida ao usuário com contexto externo agregado.

No Make, começamos com um módulo Webhook para capturar a pergunta do usuário. Em seguida, um módulo HTTP envia o texto ao endpoint de embeddings da OpenAI, retornando um vetor que é usado em outra chamada HTTP à API de similaridade do Pinecone. Os documentos encontrados são agregados com o prompt original usando fórmulas do Make ou o módulo Text Aggregator, formando um prompt no formato:
Contexto: [textos retornados]
Pergunta: [input do usuário].

Esse fluxo valoriza três fases importantes: recepção da pergunta via webhook, geração de embeddings pela OpenAI e busca vetorial no Pinecone. A simplicidade do Vanilla RAG o torna ideal para casos em que sempre se requer contexto externo antes da geração de resposta.

Adaptive RAG: Decidindo se a Busca Externa é Necessária

O Adaptive RAG introduz um agente de IA que decide, caso a caso, se é preciso recorrer a buscas externas. Um modelo (por exemplo, GPT-4) analisa a pergunta e retorna “Sim” ou “Não” para a necessidade de contexto adicional. Se a resposta for “Não”, o fluxo pula a etapa de busca e chama diretamente a API de chat da OpenAI; se for “Sim”, redireciona para o fluxo Vanilla RAG.

No Make, implementamos essa lógica com um módulo HTTP que envia ao GPT-4 o prompt:
“Essa pergunta pode ser respondida sem contexto externo? Sim ou Não?”
O resultado dispara uma condicional (Router). Quando o retorno é “Não”, seguimos direto para a geração de resposta; se “Sim”, invocamos o fluxo de busca vetorial no Pinecone e depois a geração de resposta.

Essa abordagem adaptativa reduz latência e custos, pois evita chamadas desnecessárias ao Pinecone quando o modelo já dispõe de informação suficiente. Os pontos centrais são a análise preliminar com o agente de IA, a condicional no Make e o roteamento para o fluxo apropriado.

Hybrid RAG: Consultando Múltiplas Fontes de Dados

O Hybrid RAG amplia ainda mais as possibilidades, permitindo que o sistema consulte vetores, bancos relacionais e APIs GraphQL, conforme a pergunta. Um agente de roteamento (como GPT-4) define a fonte mais adequada—Pinecone, SQL ou GraphQL—e o Make ramifica o fluxo com routers específicos para cada consulta. Ao final, as respostas são consolidadas em um único contexto enviado ao modelo da OpenAI.

No Make, iniciamos com um webhook para receber a pergunta e um módulo HTTP que pergunta ao GPT-4:
“Qual fonte é mais apropriada para essa pergunta: SQL, Pinecone ou GraphQL?”
Com base na resposta, usamos condicionais:

• Pinecone: embedding + busca vetorial.
• SQL: query via módulo HTTP ou SQL.
• GraphQL: chamada ao endpoint GraphQL.
  Os resultados de cada fonte são então agregados em um texto de contexto antes da chamada final à API de chat.

A arquitetura Hybrid RAG é potente para cenários onde os dados estão dispersos em diferentes sistemas. Os elementos críticos incluem o uso de um agente de roteamento, routers no Make e a unificação dos resultados para fornecer uma resposta coesa ao usuário.

Implementação no Make: Visão Geral

Implementar fluxos de RAG no Make depende fortemente do módulo HTTP, pois não existem integrações nativas com Pinecone ou OpenAI. Cada chamada a APIs externas—embeddings, similaridade vetorial, consultas SQL ou GraphQL—é realizada via HTTP, sendo autenticada por chaves de API. Routers e condicionais implementam a lógica adaptativa ou híbrida.

Para o processo de chunking de texto, é necessário um serviço externo ou script próprio (em Replit, Cloudflare Workers, etc.), que divida o conteúdo em pedaços adequados antes de gerar embeddings. No Make, os routers distribuídos em cada etapa direcionam o fluxo conforme a arquitetura selecionada (Prep, Vanilla, Adaptive ou Hybrid).

A flexibilidade do Make permite visualizar cada nó e condicional de forma clara, facilitando manutenção e escalabilidade. A principal limitação está na ausência de módulos nativos para Pinecone e no gerenciamento manual de chunking, mas isso pode ser contornado com integrações HTTP eficientes.

Ferramentas Externas para Integração

Para dar suporte aos fluxos de RAG, distintas APIs e serviços são necessários. A OpenAI API provê endpoints de embeddings e chat completions. O Pinecone serve como banco vetorial para armazenar e buscar embeddings. Supabase oferece um banco relacional SQL com API REST, e Hasura pode atuar como wrapper GraphQL para Postgres.

Ferramentas como Webhook.site são úteis para testes de integração via webhook, possibilitando simular chamadas de entrada. Já Docparser e Mindee auxiliam na extração de texto de documentos, enquanto serviços de hospedagem de scripts viabilizam o chunking automatizado. Essas integrações compõem o ecossistema de suporte à RAG no Make.

A escolha das ferramentas dependerá da origem dos dados, da necessidade de processamento prévio e do volume de chamadas. Em geral, a combinação de OpenAI + Pinecone + Supabase/Hasura cobre a maioria dos cenários de recuperação e geração aumentada.

Considerações Finais e Próximos Passos

A implementação de arquiteturas RAG no Make viabiliza soluções de IA robustas, capazes de responder com precisão usando dados atualizados. Desde a preparação de dados (Prep) até fluxos adaptativos e híbridos, cada abordagem atende a requisitos específicos de complexidade e desempenho. O uso de routers e condicionais no Make torna possível alternar dinamicamente entre estratégias de busca.

É fundamental contar com ferramentas externas para processamento de texto e chunking, bem como depender de APIs externas para embeddings, similaridade vetorial e geração de respostas. Esse ecossistema integrado amplia as capacidades do Make além de suas limitações nativas.

Como próximos passos, recomenda-se criar dashboards de monitoramento dos fluxos, automatizar a atualização de índices no Pinecone e explorar recursos avançados de agentes de IA para roteamento e enriquecimento dos prompts. A evolução contínua dessas arquiteturas abrirá caminho para aplicações ainda mais inteligentes e eficientes.

Conclusão

Este artigo apresentou quatro arquiteturas práticas de Retrieval-Augmented Generation—Prep, Vanilla RAG, Adaptive RAG e Hybrid RAG—e demonstrou como implementá-las no Make, utilizando o módulo HTTP e integrações externas. Cada fluxo foi descrito em detalhes, incluindo gatilhos, módulos e lógica de roteamento, garantindo uma visão completa para profissionais que desejam adotar RAG em seus projetos.

A preparação de dados no Pinecone é o alicerce que sustenta todas as demais arquiteturas, enquanto a escolha entre Vanilla, Adaptive ou Hybrid RAG depende da necessidade de balancear simplicidade, eficiência e acesso a múltiplas fontes de dados. A flexibilidade do Make, aliada a serviços como OpenAI, Pinecone, Supabase e Hasura, possibilita criar pipelines de RAG escaláveis e adaptáveis.

O próximo passo é aplicar esses conceitos em casos reais, testando performance, custo e qualidade das respostas. Com base nos resultados, é possível refinar prompts, ajustar parâmetros de chunking e explorar agentes de IA mais avançados para direcionar fluxos de maneira ainda mais inteligente.

Referências

Fonte: Langtrace. “Implementando RAG usando LlamaIndex, Pinecone e Langtrace: Um Guia Passo a Passo”. Disponível em: https://www.langtrace.ai/blog/implementing-rag-using-llamaindex-pinecone-and-langtrace-a-step-by-step-guide
Fonte: AMA Technology Blog. “Combinando Langchain e LlamaIndex para construir seu primeiro sistema RAG Agente”. Disponível em: https://medium.com/ama-tech-blog/combining-langchain-and-llamaindex-to-build-your-first-agentic-rag-system-6e8e2e7825e7
Fonte: DataCamp. “Implementando RAG com Llama 3.1 8B, Ollama e Langchain: Tutorial”. Disponível em: https://www.datacamp.com/pt/tutorial/llama-3-1-rag
Fonte: Medium | CodeX. “Construindo um Modelo de Geração Aumentada por Recuperação (RAG) Usando LangChain, LlamaIndex e OpenAI”. Disponível em: https://medium.com/codex/building-a-retrieval-augmented-generation-rag-model-using-langchain-llamaindex-and-openai-9952139346da
*Fonte: freeCodeCamp. “Como Construir um Pipeline RAG com LlamaIndex”. Disponível em: https://www.freecodecamp.org/news/how-to-build-a-rag-pipeline-with-llamaindex/