Construí um Sistema RAG de Produção por $5/mês (A Maioria das Alternativas Custa $100-200+)

[Devy]

Construí um Sistema RAG em Produção por $5/mês (A Maioria das Alternativas Custa $100-200+)

Post original por @dannwaneri no dev.to

Repositório: GitHub - dannwaneri/vectorize-mcp-worker

TL;DR

Implantei um sistema de busca semântica na borda da Cloudflare que custa $5-10/mês em vez dos típicos $100-200+. É mais rápido, segue padrões de arquitetura MCP composável empresarial e lida com tráfego em produção. Veja como.

---

O Problema: Busca com IA é Cara

No mês passado, analisei os custos típicos de infraestrutura de IA e percebi por que tantas startups têm dificuldade em adicionar busca semântica.

Stack RAG tradicional (para ~10.000 buscas/mês):

• Banco de dados vetorial Pinecone: $50-70/mês (plano Standard mínimo)
• API de embeddings OpenAI: $30-50/mês (baseado em uso)
• Servidor AWS EC2 (t3.medium): $35-50/mês
• Monitoramento/logging: $15-20/mês

Total: $130-190/mês para um recurso que deveria ser essencial.

Para uma startup bootstrapped tentando adicionar “busca com IA” à sua documentação? Isso é $1.560-2.280/ano antes de você ter ganho um único dólar com o recurso.

Algo tinha que mudar.

A Hipótese: E Se Tudo Rodasse na Borda?

Eu tinha estado construindo servidores MCP no Cloudflare Workers (escrevi sobre isso aqui), e continuava pensando: Por que RAG não pode rodar inteiramente na borda?

A configuração tradicional tem muito mais saltos:

Usuário → Servidor de Aplicativo → OpenAI (embeddings) → Pinecone (busca) → Usuário

Cada salto adiciona latência. Cada serviço adiciona custo.

E se pudéssemos fazer isso em vez disso:

Usuário → Borda Cloudflare (embeddings + busca + resposta) → Usuário

Tudo em um lugar. Sem viagens de ida e volta. Sem servidores ociosos queimando dinheiro.

A Arquitetura: Coloque Tudo Junto

Aqui está o que construí:

Vectorize MCP Worker - Um único Cloudflare Worker que lida com:

1. Geração de embeddings (Workers AI)
2. Busca vetorial (Vectorize)
3. Formatação de resultados (no worker)
4. Autenticação (integrada)

Toda a stack roda na borda da Cloudflare em 300+ cidades globalmente.

Stack Técnica

• Workers AI: modelo bge-small-en-v1.5 (embeddings de 384 dimensões)
• Vectorize: banco de dados vetorial gerenciado da Cloudflare (indexação HNSW)
• TypeScript: segurança de tipo completa
• API HTTP: funciona de qualquer lugar

Código Principal (Simplificado)

Endpoint de busca:

async function searchIndex(query: string, topK: number, env: Env) {
  const startTime = Date.now();
  
  // Gerar embedding (roda na borda)
  const embeddingStart = Date.now();
  const embedding = await env.AI.run("@cf/baai/bge-small-en-v1.5", {
    text: query,
  });
  const embeddingTime = Date.now() - embeddingStart;

  // Buscar vetores (também na borda)
  const searchStart = Date.now();
  const results = await env.VECTORIZE.query(embedding, {
    topK,
    returnMetadata: true,
  });
  const searchTime = Date.now() - searchStart;

  return {
    query,
    results: results.matches,
    performance: {
      embeddingTime: `${embeddingTime}ms`,
      searchTime: `${searchTime}ms`,
      totalTime: `${Date.now() - startTime}ms`
    }
  };
}

É isso. Sem orquestração complexa. Sem service mesh. Apenas Workers AI + Vectorize.

Arquitetura MCP Composável na Prática

Discussões recentes sobre MCP empresarial (série excelente do Workato) destacam que a maioria das implementações falha ao expor APIs brutas em vez de skills composáveis.

O Problema com Implementações MCP Ingênuas

Muitas equipes constroem servidores MCP envolvendo APIs existentes:

• get_guest_by_email
• get_booking_by_guest
• create_payment_intent
• charge_payment_method
• send_receipt_email
• … 47 ferramentas no total

O LLM deve orquestrar 6+ chamadas de API por tarefa. Resultado: lento, propenso a erros, UX terrível.

A Abordagem Composável

Em vez disso, este worker expõe skills de alto nível alinhados com a intenção do usuário:

• semantic_search - Encontrar informações relevantes
• intelligent_search - Buscar com síntese de IA

Uma chamada de ferramenta. Resultado completo. Backend lida com toda a complexidade.

Os 9 Padrões Empresariais

Esta implementação segue 8 dos 9 padrões MCP empresariais recomendados:

1. Identificadores de Negócio Sobre IDs de Sistema

// Usuários buscam com linguagem natural
{ "query": "Como funciona a computação na borda?" }

// Não com IDs de banco de dados
{ "vector_id": "a0I8d000001pRmXEAU" }

2. Operações Atômicas

Uma chamada de ferramenta lida com todo o fluxo de trabalho:

• Gerar embedding (Workers AI)
• Buscar vetores (Vectorize)
• Formatar resultados
• Retornar métricas de desempenho

Nenhuma orquestração multi-etapa necessária.

3. Padrões Inteligentes

{
  "query": "obrigatório",
  "topK": "padrão de 5"  // Reduzir carga cognitiva
}

4. Autorização Integrada

// Modo de produção requer chave de API
// Modo dev permite testes sem autenticação
// Ferramentas são automaticamente escopo
if (env.API_KEY && !isAuthorized(request)) {
  return new Response("Não autorizado", { status: 401 });
}

5. Documentação de Erros

Cada erro inclui dicas acionáveis:

{
  "error": "topK deve estar entre 1 e 20",
  "hint": "Ajuste seu parâmetro topK para um valor entre 1-20"
}

6. Desempenho Observável

Cronometragem integrada para cada requisição:

{
  "performance": {
    "embeddingTime": "142ms",
    "searchTime": "223ms",
    "totalTime": "365ms"
  }
}

7. Alinhamento com Linguagem Natural

Nomes de ferramentas correspondem a como as pessoas realmente falam:

• “Buscar X” → semantic_search
• Não “query_vector_database_with_cosine_similarity”

8. Composição Defensiva

O endpoint /populate é idempotente - seguro para chamar várias vezes.

Comparação de Benchmark

Design composável empresarial (dos benchmarks do Workato):

• Tempo de resposta: 2-4 segundos
• Taxa de sucesso: 94%
• Ferramentas necessárias: 12
• Chamadas por tarefa: 1,8

Esta implementação:

• Tempo de resposta: 365ms (6-10x mais rápido)
• Taxa de sucesso: ~100% (determinístico)
• Ferramentas necessárias: 2 (mínimo)
• Chamadas por tarefa: 1 (uma única chamada)

A diferença: implantação na borda + abstração apropriada.

O Princípio da Arquitetura

Seguindo a orientação do Workato:

“Deixe os LLMs lidarem com a intenção, deixe os backends lidarem com a execução.”

Responsabilidades do LLM (Não-determinístico):

• Entender consultas do usuário
• Selecionar semantic_search vs intelligent_search
• Interpretar resultados para usuários

Responsabilidades do Backend (Determinístico):

• Gerar embeddings de forma confiável
• Consultar vetores atomicamente
• Lidar com erros graciosamente
• Garantir desempenho consistente
• Gerenciar autenticação

Esta separação cria ferramentas MCP confiáveis, rápidas e amigáveis ao usuário - não wrappers de API frágeis.

Os Resultados: Melhor E Mais Barato

Desempenho (Dados Reais de Produção)

Testei isso de Port Harcourt, Nigéria para a borda da Cloudflare em 23 de dezembro de 2024:

Operação	Tempo
Geração de embedding	142ms
Busca vetorial	223ms
Formatação de resposta	<5ms
Total	365ms

Nota: O desempenho varia por região e carga. Estas são medições reais da implantação em produção.

Análise de Custo (Uso Real)

Para 10.000 buscas/dia (300K/mês):

Minha Solução:

• Workers: ~$3/mês (baseado em tempo de CPU)
• Workers AI: ~$3-5/mês (em $0,011 por 1K neurônios)
• Vectorize: ~$2/mês (dimensões de consulta)
• Total: $8-10/mês

Alternativas Tradicionais (estimado para mesmo volume):

• Pinecone Standard: $50-70/mês (mínimo + uso)
• Weaviate Cloud: $25-40/mês (depende do armazenamento)
• pgvector auto-hospedado: $40-60/mês (servidor + manutenção)

Economia: 85-95% dependendo da alternativa escolhida.

O Nível Gratuito é Generoso

O nível gratuito da Cloudflare cobre:

• 100.000 requisições de Workers/dia
• 10.000 neurônios de IA/dia
• 30M consultas Vectorize/mês

A maioria dos projetos paralelos e pequenas empresas nunca sai do nível gratuito.

Recursos de Produção (Porque Não É Apenas uma Demo)

1. Autenticação

// Chave de API opcional para produção
if (env.API_KEY && !isAuthorized(request)) {
  return new Response("Não autorizado", { status: 401 });
}
```Dev mode funciona sem autenticação. Produção requer. Simples.

### 2. Monitoramento de Performance
Cada resposta inclui timing:
```json
{
  "query": "edge computing",
  "results": [...],
  "performance": {
    "embeddingTime": "142ms",
    "searchTime": "223ms", 
    "totalTime": "365ms"
  }
}

Nenhuma ferramenta APM separada necessária. Está integrada.

3. API Auto-Documentada

Acesse GET / para a documentação completa da API:

{
  "name": "Vectorize MCP Worker",
  "endpoints": {
    "POST /search": "Pesquisa no índice",
    "POST /populate": "Adiciona documentos",
    "GET /stats": "Estatísticas do índice"
  }
}

4. Suporte CORS

Pré-configurado para aplicações web. Funciona.

Casos de Uso que Funcionaram

Busca em Documentação Interna

Startup de 50 pessoas com documentos espalhados entre Notion, Google Docs, Confluence.

Antes: Busca manual. Funcionários desperdiçavam 30 min/dia procurando respostas.
Depois: Busca semântica encontra o documento certo em segundos.
Custo: $5/mês (vs. $70 para Algolia DocSearch)

Base de Conhecimento de Suporte ao Cliente

SaaS com 500 artigos de suporte.

Antes: Busca por palavras-chave perdia artigos relevantes.
Depois: Busca com IA sugere correspondências perfeitas.
Custo: $10/mês (vs. $200+ para soluções enterprise)

Assistente de Pesquisa

Acadêmico com 1.000 PDFs.

Antes: Ctrl+F em arquivos individuais.
Depois: Consulta toda a biblioteca semanticamente.
Custo: $8/mês

O Que Aprendi

O Que Funcionou

1. Arquitetura edge-first é transformadora

Colocar tudo no edge eliminou saltos de rede. A melhoria de performance é imediata e mensurável.

2. Design de ferramentas compostas supera wrappers de API

Expor habilidades de alto nível em vez de APIs brutas tornou o sistema mais rápido e confiável. O LLM se concentra em intenção, não em orquestração.

3. Preços serverless mudam tudo

Quando você não paga por servidores ociosos, pode experimentar livremente. Lançar na sexta, uso dispara? Sem problema. Escala automaticamente.

4. HTTP simples supera SDKs sofisticados

Sem conflitos de versão. Sem dependency hell. Apenas curl ou fetch. Funciona de Python, Node, Go, o que for.

O Que Poderia Ser Melhor

1. Dev local é desconfortável

Vectorize não funciona em wrangler dev. Você precisa fazer deploy para testar busca. Trade-off: iteração rápida em tudo mais, deploy para testes completos.

2. Atualizações da base de conhecimento requerem redeploy

Atualmente, você edita o código e faz redeploy. Futuro: API de upload dinâmico. Trade-off: segurança vs. conveniência.

3. 384 dimensões podem não ser suficientes para domínios especializados

O modelo bge-small-en-v1.5 é ótimo para texto geral. Domínios médicos ou legais podem se beneficiar de modelos maiores. Trade-off: velocidade vs. precisão.

Detalhes de Comparação de Custos

Metodologia: Todos os custos estimados para 10.000 buscas/dia (300K/mês) com 10.000 vetores armazenados em 384 dimensões.

Solução	Custo Mensal	Notas
Este Worker	$8-10	Taxas publicadas da Cloudflare
Pinecone Standard	$50-70	Mínimo $50 + uso
Weaviate Serverless	$25-40	Preços baseados em uso
Self-hosted + pgvector	$40-60	Servidor + manutenção

Preços em dezembro de 2024. Seus custos reais podem variar com base em padrões de uso.

Como Fazer Deploy Você Mesmo

É open source: GitHub - dannwaneri/vectorize-mcp-worker

Setup em 5 minutos:

# Clone
git clone https://github.com/dannwaneri/vectorize-mcp-worker
cd vectorize-mcp-worker
npm install

# Cria índice de vetores
wrangler vectorize create mcp-knowledge-base --dimensions=384 --metric=cosine

# Deploy
wrangler deploy

# Define chave de API para produção
openssl rand -base64 32 | wrangler secret put API_KEY

# Popula com seus dados
curl -X POST https://your-worker.workers.dev/populate \
  -H "Authorization: Bearer YOUR_KEY"

# Busca
curl -X POST https://your-worker.workers.dev/search \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "sua pergunta", "topK": 3}'

Demo ao vivo: https://vectorize-mcp-worker.fpl-test.workers.dev

O Caso de Negócio

Se você é:

Fundador de startup: Pare de pagar demais por infraestrutura de IA. Faça deploy disso por $5/mês e foque seu orçamento em features que o diferenciam.

Consultor/Agência: Agora você pode incluir com lucro busca com IA em projetos de preço fixo. Sem dores de cabeça de infraestrutura para gerenciar.

Equipe Enterprise: Faça deploy de busca por departamento sem precisar de aprovação de orçamento para $1.500+/ano por equipe.

Construtor de MCP Server: Use isso como implementação de referência para design de ferramentas compostas que segue as melhores práticas enterprise.

A economia faz sentido. O que costumava exigir um item de linha dedicado agora é mais barato que o orçamento de café diário da sua equipe.

Como Isso Se Compara com Alternativas?

vs. DBs de Vetores Gerenciados (Pinecone, Weaviate)

Quando usar isso: Precisa cortar custos 90%+ mantendo performance
Quando usar eles: Precisa de features enterprise como namespaces, RBAC, etc.

vs. Busca Semântica Gerenciada (Anvitra, Algolia)

Quando usar isso: Quer controle de infraestrutura, soberania de dados, open source
Quando usar eles: Quer serviço gerenciado zero-ops com otimização de domínio

vs. Construir do Zero

Quando usar isso: Precisa de padrões MCP prontos para produção em 5 minutos
Quando usar eles: Tem requisitos únicos que exigem arquitetura customizada

Ferramentas diferentes resolvem problemas diferentes. Este worker é otimizado para:

• Infraestrutura self-hosted
• Custos transparentes e previsíveis
• Padrões MCP compostos enterprise
• Customização total (open source)

O Que Vem Depois

Estou trabalhando em:

• API de upload de documentos dinâmico (sem mudanças de código)
• Chunking semântico para documentos longos
• Suporte multi-modal (imagens, tabelas)
• Suite de testes abrangente

E estou ajudando algumas empresas a fazer deploy disso para seus casos de uso. Se você está gastando $100+/mês em busca com IA ou construindo MCP servers, vamos conversar.

Conecte-se

• GitHub: @dannwaneri
• Upwork: Perfil
• Twitter: @dannwaneri

---

Dúvidas? Comentários? Construindo ferramentas MCP compostas também? Deixe abaixo.

E se achou útil, dê uma estrela no repo: GitHub - dannwaneri/vectorize-mcp-worker

---

Relacionado: MCP Sampling on Cloudflare Workers - Como construir ferramentas MCP inteligentes sem gerenciar LLMs
Why Edge Computing Forced Me to Write Better Code - A função econômica forçada por trás dessa arquitetura

Inspirado por: Beyond Basic MCP: Why Enterprise AI Needs Composable Architecture e Designing Composable Tools for Enterprise MCP