Por que agentes sem memória não viram produto
Um agente de IA puro trabalha com o que está no contexto da conversa. Se você não passou a informação, ele não sabe.
Isso cria um problema imediato em qualquer produto real:
- Suporte ao cliente não conhece o histórico do usuário
- Assistente interno não acessa os documentos da empresa
- Bot de onboarding não sabe o que o usuário fez antes
- Chatbot de produto não conhece a base de conhecimento
A solução óbvia — jogar tudo no contexto — não escala. Modelos têm limite de tokens. E mesmo os que aceitam janelas grandes cobram caro por token processado.
RAG é a solução arquitetural para esse problema.
O que é RAG (em 2 minutos)
RAG significa Retrieval-Augmented Generation.
Traduzindo: geração de texto aumentada por recuperação de informação.
Em vez de o modelo “saber tudo” ou receber tudo no contexto, ele busca o que precisa antes de responder.
O fluxo básico:
Pergunta do usuário
→ Converte em vetor (embedding)
→ Busca documentos similares na base vetorial
→ Monta contexto com os resultados
→ Envia para o LLM com o contexto
→ LLM responde com informação real e precisa
O modelo deixa de ser uma caixa preta com conhecimento estático e passa a ser um motor de raciocínio sobre a sua base de dados.
Os três componentes de um sistema RAG
Todo RAG funcional tem três partes. Entender cada uma é o que separa quem constrói de quem só usa demo.
1. Processamento e indexação (ingestão)
Antes de responder qualquer coisa, você precisa transformar seus documentos em vetores e armazená-los.
Documentos (PDF, texto, HTML, banco de dados)
→ Chunking (divisão em pedaços menores)
→ Embedding (conversão em vetores numéricos)
→ Armazenamento no banco vetorial
Chunking é crítico: como você divide os documentos afeta diretamente a qualidade das respostas. Parágrafos curtos demais perdem contexto. Muito longos, diluem o sinal.
2. Banco vetorial (armazenamento)
Um banco vetorial armazena embeddings e permite busca por similaridade semântica. Você não busca por palavra-chave — busca por significado.
Opções para solo builders:
Para começar: ChromaDB local ou Supabase pgvector se você já usa Supabase.
3. Recuperação e geração
Na hora da query:
Query do usuário
→ Gera embedding da query
→ Busca os K documentos mais similares
→ Monta prompt: [contexto recuperado] + [pergunta]
→ Envia para o LLM
→ Retorna resposta contextualizada
A qualidade do RAG depende de: qualidade dos embeddings, estratégia de chunking e quão bem você monta o prompt com o contexto.
Como construir um RAG mínimo viável
Vamos construir um sistema funcional do zero. Usaremos Python, ChromaDB e a API da OpenAI — mas os conceitos se aplicam a qualquer stack.
Instalando as dependências
pip install chromadb openai python-dotenv
Indexando documentos
import chromadb
from openai import OpenAI
import os
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# EphemeralClient = in-memory, dados perdidos ao reiniciar (ok para testes)
# Para persistência em disco (use em produção):
# chroma_client = chromadb.PersistentClient(path="./minha_base")
chroma_client = chromadb.EphemeralClient()
collection = chroma_client.get_or_create_collection(name="minha_base")
def gerar_embedding(texto: str) -> list[float]:
resposta = client.embeddings.create(
model="text-embedding-3-small",
input=texto
)
return resposta.data[0].embedding
def indexar_documento(texto: str, doc_id: str, metadados: dict = None):
embedding = gerar_embedding(texto)
collection.add(
embeddings=[embedding],
documents=[texto],
ids=[doc_id],
metadatas=[metadados or {}]
)
# Indexando sua base de conhecimento
documentos = [
{"id": "doc1", "texto": "Nosso plano Pro custa R$97/mês e inclui suporte prioritário."},
{"id": "doc2", "texto": "Para cancelar sua assinatura, acesse Configurações > Plano > Cancelar."},
{"id": "doc3", "texto": "O período de trial é de 14 dias. Não exigimos cartão de crédito."},
]
for doc in documentos:
indexar_documento(doc["texto"], doc["id"])
print(f"Indexado: {doc['id']}")
Recuperando contexto e gerando resposta
def buscar_contexto(query: str, n_resultados: int = 3) -> list[str]:
embedding_query = gerar_embedding(query)
resultados = collection.query(
query_embeddings=[embedding_query],
n_results=n_resultados
)
docs = resultados.get("documents", [[]])
return docs[0] if docs else []
def responder_com_rag(pergunta: str) -> str:
# Recupera contexto relevante
contexto = buscar_contexto(pergunta)
contexto_formatado = "\n---\n".join(contexto)
# Monta o prompt com contexto
prompt = f"""Você é um assistente de suporte. Use apenas as informações abaixo para responder.
Se a informação não estiver disponível, diga que não sabe.
INFORMAÇÕES:
{contexto_formatado}
PERGUNTA:
{pergunta}
RESPOSTA:"""
resposta = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": prompt}],
temperature=0
)
return resposta.choices[0].message.content
# Testando
pergunta = "Quanto custa o plano Pro?"
print(responder_com_rag(pergunta))
# → "O plano Pro custa R$97/mês e inclui suporte prioritário."
Esse é o núcleo. Em menos de 60 linhas você tem um agente com memória real sobre sua base de dados.
Melhorando a qualidade: chunking estratégico
A maioria dos RAGs ruins falha no chunking. Veja a diferença:
def chunk_por_paragrafo(texto: str, overlap_palavras: int = 50) -> list[str]:
"""
Divide texto em parágrafos com sobreposição de palavras.
overlap_palavras: quantas palavras do parágrafo anterior incluir no início do próximo.
50 palavras ≈ 65–70 tokens — suficiente para manter coerência entre chunks.
"""
paragrafos = [p.strip() for p in texto.split("\n\n") if p.strip()]
chunks = []
for i, paragrafo in enumerate(paragrafos):
chunk = paragrafo
# Adiciona as últimas N palavras do parágrafo anterior
if i > 0 and overlap_palavras:
palavras_anterior = paragrafos[i-1].split()[-overlap_palavras:]
chunk = " ".join(palavras_anterior) + " " + chunk
chunks.append(chunk)
return chunks
def indexar_arquivo(caminho: str, prefixo_id: str):
with open(caminho, "r", encoding="utf-8") as f:
texto = f.read()
chunks = chunk_por_paragrafo(texto)
for i, chunk in enumerate(chunks):
doc_id = f"{prefixo_id}_chunk_{i}"
metadados = {"arquivo": caminho, "chunk_index": i}
indexar_documento(chunk, doc_id, metadados)
print(f"Indexados {len(chunks)} chunks de {caminho}")
Dica de chunking por tipo de conteúdo
- Documentação técnica: chunks por seção (H2/H3)
- FAQs: chunk por par pergunta-resposta
- PDFs longos: chunks fixos de ~500 tokens com 50–100 palavras de overlap (~65–130 tokens)
- Conversas/emails: chunk por mensagem ou thread
RAG sozinho é um QA system. Combinado com agente, vira produto. Se você ainda não construiu um agente do zero, leia antes o guia de como criar agentes de IA para automatizar tarefas — o RAG encaixa diretamente nessa estrutura.
class AgenteComMemoria:
def __init__(self, collection_name: str, system_prompt: str):
self.chroma = chromadb.PersistentClient(path=f"./{collection_name}")
self.collection = self.chroma.get_or_create_collection(collection_name)
self.system_prompt = system_prompt
self.historico = []
def adicionar_conhecimento(self, texto: str, doc_id: str):
embedding = gerar_embedding(texto)
self.collection.add(
embeddings=[embedding],
documents=[texto],
ids=[doc_id]
)
def recuperar_contexto(self, query: str, n: int = 3) -> str:
embedding = gerar_embedding(query)
resultados = self.collection.query(
query_embeddings=[embedding],
n_results=n
)
docs = resultados["documents"][0]
return "\n---\n".join(docs) if docs else ""
def responder(self, pergunta: str) -> str:
# Recupera contexto relevante
contexto = self.recuperar_contexto(pergunta)
# Monta mensagens com histórico
mensagens = [
{
"role": "system",
"content": f"{self.system_prompt}\n\nCONTEXTO RELEVANTE:\n{contexto}"
}
]
mensagens.extend(self.historico[-6:]) # Últimas 3 trocas
mensagens.append({"role": "user", "content": pergunta})
# Usa o `client` OpenAI definido globalmente no início do script
resposta = client.chat.completions.create(
model="gpt-4o-mini",
messages=mensagens,
temperature=0.3
)
resposta_texto = resposta.choices[0].message.content
# Atualiza histórico
self.historico.extend([
{"role": "user", "content": pergunta},
{"role": "assistant", "content": resposta_texto}
])
return resposta_texto
# Uso
agente = AgenteComMemoria(
collection_name="suporte_produto",
system_prompt="Você é um assistente de suporte especializado. Seja direto e útil."
)
# Indexa a base de conhecimento
agente.adicionar_conhecimento("Plano Pro: R$97/mês, suporte 24h", "preco_pro")
agente.adicionar_conhecimento("Integração com Zapier disponível no plano Business", "integracao_zapier")
# Conversa com contexto
print(agente.responder("Quais planos têm integração com Zapier?"))
Este agente tem: memória semântica (RAG) + histórico conversacional + instrução de sistema. Isso é o núcleo de qualquer produto de IA que funciona.
Aqui está onde a técnica vira dinheiro.
1. Chatbot de suporte white-label
O cliente te dá os documentos (FAQ, manual do produto, políticas). Você indexa, configura o agente, entrega via widget ou API.
Modelo de negócio: Setup fee + mensalidade por uso (tokens + hosting).
Ticket médio: R$300–R$2.000/mês por cliente.
Esforço: 1–3 dias para construir a plataforma base, depois é só configuração por cliente.
2. Assistente de documentação interna para PMEs
Empresas com PDFs, wikis e manuais espalhados. Você constrói um “ChatGPT interno” sobre a documentação deles.
Modelo de negócio: Projeto pontual (R$3k–R$15k) + manutenção mensal.
Diferencial: Privacidade (roda em infra deles ou sua, sem dados no GPT).
3. Research assistant para nichos específicos
Indexa bases de dados públicas relevantes para um nicho (jurídico, médico, financeiro, imobiliário) e cobra por consulta ou assinatura.
Modelo de negócio: SaaS com planos por volume de consultas.
Exemplo: Assistente de jurisprudência para advogados autônomos.
4. API de RAG como serviço
Você constrói a infraestrutura, o cliente traz os dados via API. Cobra por indexação + queries.
Modelo de negócio: Pay-per-use ou planos com volume incluído.
Para quem: Devs que não querem construir a infra do zero.
5. Agente de onboarding inteligente
Para SaaS, o agente conhece toda a documentação do produto e guia novos usuários de forma contextual.
Modelo de negócio: Feature premium embutida no produto ou plugin independente.
Stack recomendada para solo builders
Para começar (validação rápida)
Embeddings: text-embedding-3-small (OpenAI) — barato, bom
Vector DB: ChromaDB local — zero configuração
LLM: gpt-4o-mini — custo baixo
Framework: Python puro — sem overhead
Para produção
Embeddings: text-embedding-3-small (OpenAI) ou BGE-M3 (open source)
Vector DB: Supabase pgvector (SQL + vetorial numa stack só)
LLM: gpt-4o-mini / Claude Haiku (custo) ou Claude Sonnet (qualidade)
Framework: FastAPI — simples, rápido, fácil de dockerizar
Deploy: Fly.io, Railway ou Render
Links: FastAPI · Fly.io · Railway · Render · BGE-M3 no HuggingFace
Para escala ou privacidade total
Embeddings: Sentence Transformers (self-hosted)
Vector DB: Qdrant (performance excelente)
LLM: Ollama + Mistral/Llama (self-hosted, sem custo de API)
Framework: FastAPI + Celery para indexação assíncrona
Links: Sentence Transformers · Qdrant · Ollama
Para a opção self-hosted com Ollama e Mistral/Llama, leia antes o guia de rodar IA localmente — ele mapeia qual modelo usar de acordo com a RAM disponível.
A stack de produção com Supabase é a mais rápida de operar para um solo builder — você já tem banco relacional, autenticação e vetorial num lugar só. Vale a leitura sobre como usar Supabase com pgvector antes de escolher sua stack. Para uma visão completa das ferramentas de IA para operar solo em 2026, veja o stack completo do solopreneur.
Erros comuns que destroem a qualidade do RAG
1. Chunks muito grandes ou muito pequenos
Chunks de 50 tokens perdem contexto. Chunks de 2.000 tokens diluem o sinal. Comece com 300–500 tokens com 50–100 palavras de overlap (~65–130 tokens).
2. Não filtrar por metadados
Se sua base tem documentos de clientes diferentes, adicione client_id nos metadados e filtre na query. Sem isso, um cliente pode ver dados de outro. O fix é simples:
# Correto: filtrar por client_id na query
resultados = collection.query(
query_embeddings=[embedding_query],
n_results=3,
where={"client_id": "empresa_xyz"}
)
Para isolamento em produção, o Supabase com Row Level Security é a solução mais robusta para multi-tenancy.
3. Ignorar a qualidade do prompt de sistema
O contexto recuperado não é suficiente. O prompt de sistema precisa instruir o modelo sobre como usar o contexto, o que fazer quando não encontrar informação, e o tom da resposta.
4. Não versionar os documentos indexados
Quando o documento fonte muda, o índice precisa ser atualizado. Construa um processo de re-indexação. Simples mas crítico em produção.
5. Usar o modelo de embedding errado
text-embedding-3-small da OpenAI funciona bem para a maioria dos casos em português e inglês. Para domínios muito específicos, considere fine-tuning ou modelos especializados.
FAQ
Posso usar RAG com documentos PDF?
Sim. Use pdfplumber ou pypdf para extrair o texto do PDF, depois passe para o pipeline de chunking normalmente. pip install pdfplumber e text = pdfplumber.open("doc.pdf").pages[0].extract_text() já resolvem a maioria dos casos. Para PDFs com tabelas ou layout complexo, pdfplumber tem melhor fidelidade.
RAG funciona bem em português?
Sim. Os modelos de embedding modernos (text-embedding-3-small, BGE-M3) têm boa performance em português. Teste com sua base antes de escalar.
Preciso de GPU para rodar RAG?
Não, se você usar a API da OpenAI para embeddings e o LLM. Para rodar tudo localmente (embeddings + LLM), uma GPU ajuda, mas modelos menores rodam em CPU.
Qual é o custo de operação?
Para um produto com ~1.000 queries/dia usando text-embedding-3-small + gpt-4o-mini, o custo fica na faixa de US$5–15/mês dependendo do tamanho dos documentos. Barato o suficiente para validar.
RAG vs fine-tuning: quando usar cada um?
RAG é para conhecimento externo e dinâmico (documentos que mudam, bases de dados, contexto por usuário). Fine-tuning é para estilo, formato e comportamento do modelo. Na maioria dos produtos reais, você quer RAG. Fine-tuning é caro, lento e não resolve o problema de memória contextual.
Como evitar que o agente “alucine” com RAG?
Use temperature=0 ou baixo. Instrua explicitamente: “Se a informação não estiver no contexto fornecido, diga que não sabe.” Adicione uma etapa de verificação se a qualidade for crítica.
Por Onde Começar: Implementando RAG Hoje
Você tem o código. Você tem o mapa de monetização. O que falta é escolher um nicho e construir a versão mínima.
A recomendação prática: escolha um tipo de documento que você conhece bem (documentação de um produto que usa, base de conhecimento de um nicho que entende) e construa um chatbot funcional em uma tarde. Teste com usuários reais antes de qualquer coisa mais complexa.
Para ir além na construção de agentes, leia o guia completo de agentes de IA autônomos e entenda como conectar RAG a fluxos de ação. É a combinação que transforma um QA system em agente útil de verdade.
Se você quer entender como transformar isso em micro-SaaS completo, o próximo passo natural é montar o plano de negócio em volta da infra que você acabou de construir. Para quem está partindo do zero, o guia do zero ao produto com IA mostra como encaixar RAG dentro de um produto lançável.
Escolha um documento que você já tem — FAQ de produto, manual interno, base de suporte — e indexe agora. O setup leva menos de uma hora.
