Base de conhecimento com IA em 20 minutos? Aprenda RAG com Workers AI e Vectorize (código completo)

Eu queria criar um atendimento inteligente para a empresa e fui procurar tutoriais de RAG. Alguns ficavam presos em uma teoria nebulosa; outros já começavam pedindo para alugar uma GPU e configurar todo o ambiente. Só para ajustar o LangChain e o banco de dados vetorial, dava para perder dois dias sem nem ter certeza de que tudo funcionaria.

Depois descobri que a Cloudflare tinha lançado um conjunto completo de ferramentas de IA: Workers AI, Vectorize e D1. Tudo é gerenciado, e a cota gratuita é bem generosa. Resolvi montar com elas uma aplicação de perguntas e respostas sobre anotações. Do zero até algo utilizável, levei mesmo menos de 20 minutos, com pouco mais de cem linhas de código.

Neste artigo, você vai acompanhar todo o processo passo a passo:

• Entender primeiro o que é RAG, sem uma enxurrada de termos técnicos
• Criar na prática uma aplicação funcional de perguntas e respostas sobre uma base de conhecimento, com o código completo
• Aplicar otimizações para aumentar a precisão da recuperação e reduzir custos
• Implantar a aplicação para começar a usá-la de verdade

Você só precisa conhecer um pouco de JavaScript e ter uma conta gratuita da Cloudflare. Seguindo as etapas, dá para construir tudo sem dificuldade.

O que é RAG? Entenda como funciona em 5 minutos

Uma prova com consulta ajuda a entender o RAG

Vamos começar com uma comparação simples. Em uma prova sem consulta, você só consegue responder com o que guardou na memória. Se esquecer algo, corre o risco de inventar. Em uma prova com consulta, é possível conferir livros e materiais quando houver dúvida, o que aumenta bastante a precisão.

RAG (geração aumentada por recuperação) dá à IA essa possibilidade de consultar materiais.

Um LLM tradicional se parece com uma prova sem consulta: ele só responde com base nos dados vistos durante o treinamento. Isso traz alguns problemas:

• Os dados de treinamento envelhecem e não incluem as novidades mais recentes
• O modelo nunca viu os documentos internos da sua empresa
• Ele não guarda todos os detalhes e pode inventar informações, fenômeno conhecido como “alucinação”

Com RAG, o sistema primeiro procura materiais relevantes na base de conhecimento preparada por você. Depois, entrega esse conteúdo à IA para que ela formule a resposta. Assim, as respostas ficam mais confiáveis e também podem incorporar informações recentes.

As três etapas essenciais do RAG

O fluxo inteiro tem apenas três etapas:

Etapa 1: transformar o conhecimento em vetores e armazená-los

Imagine que você tenha vários documentos. O RAG converte cada trecho de texto em uma sequência de números, chamada tecnicamente de “vetor” ou “embedding”. Essa sequência representa o significado do texto.

Por exemplo, “gatos são muito fofos” e “os gatinhos são uma graça” usam palavras diferentes, mas têm sentidos próximos. Depois da conversão, os vetores dessas frases também ficam próximos. Esses vetores são armazenados em um banco de dados vetorial como o Vectorize.

Etapa 2: quando o usuário faz uma pergunta, encontrar os trechos mais relevantes

Quando alguém pergunta “como treinar um gato?”, o sistema também transforma a pergunta em um vetor. Em seguida, procura no banco os trechos com a menor “distância”, ou seja, os conteúdos semanticamente mais relacionados.

Esse processo é chamado de “busca por similaridade”. Ele é rápido: em poucos milissegundos, consegue encontrar os três a cinco melhores resultados entre dezenas de milhares de registros.

Etapa 3: enviar o conteúdo recuperado ao LLM para gerar a resposta

Depois de localizar o conteúdo relevante, o sistema monta um prompt e o envia à IA:

Estes são os materiais relevantes:
[conteúdo recuperado 1]
[conteúdo recuperado 2]
...
Pergunta do usuário: como treinar um gato?
Responda com base nos materiais acima.

Com esses “materiais de referência”, a IA consegue produzir uma resposta precisa e fundamentada.

Por que escolher o conjunto de serviços da Cloudflare?

Existem muitas maneiras de criar uma aplicação RAG. LangChain e LlamaIndex, por exemplo, funcionam bem, mas normalmente exigem configurar o ambiente, escolher um banco de dados vetorial e administrar recursos de GPU. Isso dá bastante trabalho.

O conjunto da Cloudflare oferece algumas vantagens:

Workers AI — inclui mais de dez modelos de código aberto, como Llama 3 e Claude, acessíveis por API, sem que você precise alugar uma GPU. A camada gratuita oferece uma cota diária fixa de Neurons, a unidade de medição do serviço, suficiente para projetos pessoais.

Vectorize — é um banco de dados vetorial gerenciado, sem a necessidade de instalar e manter soluções como Milvus ou Pinecone. Poucas linhas de código bastam para criar um índice, inserir vetores e fazer buscas por similaridade.

D1 — é o banco de dados SQLite da Cloudflare, usado aqui para armazenar o texto original. O banco vetorial guarda os vetores, mas ainda precisamos recuperar o conteúdo textual em algum lugar.

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

Tudo gerenciado — essa é a parte mais conveniente. Você não precisa se preocupar com servidores, expansão de capacidade ou backups e pode se concentrar no código. A rede de borda da Cloudflare também oferece acesso rápido em todo o mundo.

"Em 2025, a Cloudflare lançou o AutoRAG, que automatiza a divisão dos documentos, a vetorização, a recuperação e a geração depois que os arquivos são enviados ao R2"

Em 2025, a Cloudflare também lançou o AutoRAG, simplificando ainda mais o fluxo: depois de enviar os documentos ao R2, a divisão, a vetorização, a recuperação e a geração são feitas automaticamente. Mesmo assim, neste artigo vamos montar tudo manualmente para entender os fundamentos.

Com a teoria explicada, é hora de colocar a mão na massa.

Na prática: crie sua primeira aplicação RAG

Vamos desenvolver uma aplicação de perguntas e respostas sobre anotações. O usuário poderá adicionar notas e fazer perguntas; o sistema encontrará o conteúdo relevante entre todas elas para formular a resposta.

Inicialização do projeto e preparação do ambiente

Primeiro, instale o Wrangler, a ferramenta de linha de comando da Cloudflare:

npm install -g wrangler
wrangler login  # 登录你的 Cloudflare 账号

Crie o projeto:

npm create cloudflare@latest rag-notes-app
# 选择 "Hello World" worker
# 选择 TypeScript
cd rag-notes-app

Instale o Hono, uma biblioteca de roteamento mais prática que a API nativa do Workers:

npm install hono

Crie o banco de dados D1 e o índice do Vectorize:

# 创建 D1 数据库存原始笔记
wrangler d1 create notes-db
# 创建 Vectorize 索引（768 维，配合 bge-base-en-v1.5 模型）
wrangler vectorize create notes-index --dimensions=768 --metric=cosine

Em seguida, configure o wrangler.jsonc (ou wrangler.toml):

{
  "name": "rag-notes-app",
  "main": "src/index.ts",
  "compatibility_date": "2024-01-01",
  "node_compat": true,
  // AI 绑定
  "ai": {
    "binding": "AI"
  },
  // D1 数据库绑定
  "d1_databases": [
    {
      "binding": "DB",
      "database_name": "notes-db",
      "database_id": "你的数据库ID"  // 从上面创建命令的输出复制
    }
  ],
  // Vectorize 索引绑定
  "vectorize": [
    {
      "binding": "VECTORIZE",
      "index_name": "notes-index"
    }
  ],
  // Workflow 绑定（处理异步向量化任务）
  "workflows": [
    {
      "binding": "RAG_WORKFLOW",
      "name": "rag-workflow",
      "class_name": "RAGWorkflow"
    }
  ]
}

Inicialize a tabela do banco de dados:

-- schema.sql
CREATE TABLE IF NOT EXISTS notes (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  text TEXT NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

Execute:

wrangler d1 execute notes-db --file=./schema.sql

Implementação da entrada de dados na base de conhecimento

Este é o núcleo do RAG: transformar as anotações do usuário em vetores e armazená-las.

Crie src/workflow.ts para que o Workflow processe a tarefa de forma assíncrona:

import { WorkflowEntrypoint, WorkflowStep } from 'cloudflare:workers';
type Env = {
  AI: Ai;
  DB: D1Database;
  VECTORIZE: VectorizeIndex;
};
type Params = {
  noteId: number;
  text: string;
};
export class RAGWorkflow extends WorkflowEntrypoint<Env, Params> {
  async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
    const { noteId, text } = event.payload;
    // 步骤1：确认 D1 记录已创建（由主路由完成）
    // 步骤2：生成向量
    const embeddings = await step.do('generate embeddings', async () => {
      const response = await this.env.AI.run(
        '@cf/baai/bge-base-en-v1.5',  // 768维的 Embedding 模型
        { text: [text] }
      );
      return response.data[0];  // 返回向量数组
    });
    // 步骤3：插入 Vectorize
    await step.do('insert vector', async () => {
      await this.env.VECTORIZE.insert([
        {
          id: noteId.toString(),
          values: embeddings,
          metadata: { text }  // 存一份文本方便调试
        }
      ]);
    });
  }
}

No roteador principal, src/index.ts, processe a inclusão das notas:

import { Hono } from 'hono';
import { RAGWorkflow } from './workflow';
type Bindings = {
  AI: Ai;
  DB: D1Database;
  VECTORIZE: VectorizeIndex;
  RAG_WORKFLOW: Workflow;
};
const app = new Hono<{ Bindings: Bindings }>();
// 添加笔记
app.post('/notes', async (c) => {
  const { text } = await c.req.json<{ text: string }>();
  if (!text?.trim()) {
    return c.json({ error: 'Text is required' }, 400);
  }
  // 插入 D1
  const result = await c.env.DB.prepare(
    'INSERT INTO notes (text) VALUES (?) RETURNING id'
  ).bind(text).first<{ id: number }>();
  if (!result) {
    return c.json({ error: 'Failed to create note' }, 500);
  }
  // 触发 Workflow 异步生成向量
  await c.env.RAG_WORKFLOW.create({
    params: { noteId: result.id, text }
  });
  return c.json({
    id: result.id,
    message: 'Note created, vectorization in progress'
  });
});
export default app;
export { RAGWorkflow };

Assim, quando o usuário envia uma solicitação POST para adicionar uma nota:

1. O texto é armazenado imediatamente no D1
2. Em segundo plano, o Workflow gera o vetor e o insere no Vectorize
3. Mesmo que a vetorização leve alguns segundos, a solicitação do usuário não fica bloqueada

Implementação das perguntas e respostas inteligentes

Agora que já podemos armazenar notas, vamos implementar a consulta.

Adicione o seguinte a src/index.ts:

// 查询问答
app.get('/', async (c) => {
  const query = c.req.query('q');
  if (!query) {
    return c.json({ error: 'Query parameter "q" is required' }, 400);
  }
  // 第一步：把问题转成向量
  const queryEmbedding = await c.env.AI.run(
    '@cf/baai/bge-base-en-v1.5',
    { text: [query] }
  );
  // 第二步：在 Vectorize 里找最相似的 3 条笔记
  const matches = await c.env.VECTORIZE.query(
    queryEmbedding.data[0],
    { topK: 3, returnMetadata: true }
  );
  if (matches.count === 0) {
    return c.json({ answer: '没有找到相关笔记' });
  }
  // 第三步：从 D1 获取完整文本（如果需要）
  const noteIds = matches.matches.map(m => m.id);
  const notes = await c.env.DB.prepare(
    `SELECT text FROM notes WHERE id IN (${noteIds.map(() => '?').join(',')})`
  ).bind(...noteIds).all();
  // 第四步：构造 Prompt，调用 LLM 生成答案
  const context = notes.results.map((n: any) => n.text).join('\n\n---\n\n');
  const prompt = `以下是相关的笔记内容：
${context}
用户问题：${query}
请基于上述笔记内容回答用户问题。如果笔记中没有相关信息，请说明。`;
  const aiResponse = await c.env.AI.run(
    '@cf/meta/llama-3-8b-instruct',  // 或者用 claude-3-5-sonnet-latest
    {
      messages: [
        { role: 'system', content: '你是一个智能笔记助手' },
        { role: 'user', content: prompt }
      ]
    }
  );
  return c.json({
    answer: aiResponse.response,
    sources: matches.matches.map(m => ({
      id: m.id,
      score: m.score,
      text: m.metadata?.text
    }))
  });
});

Faça um teste:

# 本地运行
wrangler dev
# 添加笔记
curl -X POST http://localhost:8787/notes \
  -H "Content-Type: application/json" \
  -d '{"text": "Cloudflare Workers AI 支持 Llama 3 和 Claude 模型"}'
curl -X POST http://localhost:8787/notes \
  -H "Content-Type: application/json" \
  -d '{"text": "Vectorize 使用余弦相似度进行向量检索"}'
# 等几秒让 Workflow 完成向量化
# 提问
curl "http://localhost:8787/?q=Workers%20AI%20有哪些模型"

Se tudo estiver correto, você receberá uma resposta baseada no conteúdo das notas.

Funções de exclusão e atualização

Ao excluir uma nota, lembre-se de remover os dados tanto do D1 quanto do Vectorize:

app.delete('/notes/:id', async (c) => {
  const id = c.req.param('id');
  // 从 D1 删除
  await c.env.DB.prepare('DELETE FROM notes WHERE id = ?').bind(id).run();
  // 从 Vectorize 删除
  await c.env.VECTORIZE.deleteByIds([id]);
  return c.json({ message: 'Note deleted' });
});

Para atualizar uma nota, a abordagem mais simples é excluí-la e adicioná-la de novo, gerando um novo vetor.

O código completo está disponível no exemplo oficial da Cloudflare.

Otimizações avançadas para deixar seu RAG mais inteligente

As funções básicas já estão funcionando, mas há alguns detalhes que vale a pena otimizar antes de usar a aplicação em um projeto real.

Estratégia de divisão do texto

Até agora, armazenamos cada nota inteira como uma unidade. Isso pode causar problemas quando a nota é muito longa, como em um documento técnico:

1. A similaridade do documento completo pode ser baixa, mesmo que alguns parágrafos sejam relevantes
2. Um prompt muito longo pode ultrapassar o limite da janela de contexto do LLM

Uma abordagem melhor é dividir textos longos em blocos menores, ou chunks, e gerar um vetor separado para cada bloco.

Um método simples de divisão:

function splitText(text: string, chunkSize: number = 500, overlap: number = 50): string[] {
  const chunks: string[] = [];
  let start = 0;
  while (start < text.length) {
    const end = Math.min(start + chunkSize, text.length);
    chunks.push(text.slice(start, end));
    start = end - overlap;  // 重叠一点，避免句子被切断
  }
  return chunks;
}

Uma alternativa mais inteligente é dividir por parágrafos ou por significado, por exemplo com o RecursiveCharacterTextSplitter do LangChain. Para a maioria dos casos, porém, um tamanho fixo com uma pequena sobreposição já é suficiente.

Modifique o Workflow para atribuir um ID único a cada chunk:

const chunks = splitText(text);
for (let i = 0; i < chunks.length; i++) {
  const chunkId = `${noteId}-${i}`;
  const embeddings = await this.env.AI.run('@cf/baai/bge-base-en-v1.5', {
    text: [chunks[i]]
  });
  await this.env.VECTORIZE.insert([{
    id: chunkId,
    values: embeddings.data[0],
    metadata: { noteId, chunkIndex: i, text: chunks[i] }
  }]);
}

Como aumentar a precisão da recuperação

Ajuste o topK e o limiar de similaridade

Retornar os três melhores resultados pode ser pouco ou até demais, dependendo do caso. Experimente aumentar para cinco e filtrar os resultados com similaridade muito baixa:

const matches = await c.env.VECTORIZE.query(queryEmbedding.data[0], {
  topK: 5,
  returnMetadata: true
});
// 只保留相似度 > 0.7 的结果
const relevantMatches = matches.matches.filter(m => m.score > 0.7);

A pontuação de similaridade vai de 0 a 1, usando similaridade de cosseno. Em geral, valores acima de 0,7 indicam uma boa relação.

Otimize o prompt

Não basta entregar à IA o conteúdo recuperado. Explique como ela deve usar essas informações:

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

const prompt = `你是一个智能笔记助手。以下是从笔记库中检索到的相关内容（按相关性排序）：
${context}
请严格基于上述内容回答用户问题。如果内容不足以回答问题，明确说明"笔记中没有找到相关信息"，不要编造答案。
用户问题：${query}`;

Pontos importantes:

• Deixe claro que o material foi recuperado da base
• Exija que a resposta use somente esse conteúdo
• Permita que a IA admita quando não sabe

Essas instruções reduzem a chance de a IA inventar informações.

Controle de custos e limitação de solicitações

A camada gratuita do Workers AI tem uma cota diária de Neurons. Como o valor exato pode mudar, consulte a página de preços para ver o número mais recente.

Monitoramento do consumo:

O consumo diário aparece em Cloudflare Dashboard → Workers AI. Cada modelo consome uma quantidade diferente: modelos de embedding são baratos, enquanto a geração com LLM custa mais.

Estratégia de fallback:

Para evitar ultrapassar a cota, você pode:

1. Limitar a frequência de solicitações de cada usuário com um contador no KV ou em Durable Objects
2. Depois de atingir o limite, mudar para um modelo menor ou retornar resultados armazenados em cache
3. Em solicitações menos importantes, retornar diretamente o texto recuperado, sem chamar o LLM

// 简单限流示例
const userKey = c.req.header('X-User-ID') || 'anonymous';
const requestCount = await c.env.KV.get(`rate:${userKey}`) || 0;
if (requestCount > 100) {
  return c.json({ error: 'Rate limit exceeded' }, 429);
}
await c.env.KV.put(`rate:${userKey}`, requestCount + 1, { expirationTtl: 86400 });

Troca por um modelo mais potente

O Llama 3 8B já funciona muito bem. Se você quiser melhorar a compreensão, pode experimentar o Claude:

// 需要先在 Dashboard 绑定 Anthropic API key
const aiResponse = await c.env.AI.run('claude-3-5-sonnet-latest', {
  messages: [
    { role: 'system', content: '你是一个智能笔记助手' },
    { role: 'user', content: prompt }
  ]
});

A capacidade de compreensão e a qualidade das respostas do Claude são realmente melhores, mas ele também consome mais Neurons. Escolha de acordo com as necessidades do projeto.

Na minha experiência:

• Perguntas simples: Llama 3 é suficiente
• Raciocínio e resumo: Claude é visivelmente melhor
• Orçamento limitado: comece testando com Llama e faça a mudança quando souber exatamente do que precisa

Implantação e casos de uso reais

Processo de implantação

Depois que os testes locais estiverem funcionando, a implantação é muito simples:

wrangler deploy

Com apenas esse comando, a Cloudflare:

• Empacota o código
• Implanta a aplicação em nós de borda no mundo inteiro
• Gera um domínio .workers.dev

Você verá uma saída parecida com esta:

Published rag-notes-app
  https://rag-notes-app.your-account.workers.dev

Esse será o endereço da sua API.

Vinculação de um domínio personalizado (opcional):

Se o seu domínio estiver hospedado na Cloudflare, você poderá vinculá-lo assim:

wrangler domains add api.yourdomain.com

Outra opção é adicioná-lo em Dashboard → Workers & Pages → seu Worker → Settings → Domains.

Variáveis de ambiente e secrets:

Se você estiver usando uma chave de API da Anthropic ou outra informação confidencial:

wrangler secret put ANTHROPIC_API_KEY
# 输入你的 key

Use-a no código desta forma:

const apiKey = c.env.ANTHROPIC_API_KEY;

Casos de uso reais

Essa arquitetura RAG permite criar vários tipos de solução. Veja alguns exemplos práticos:

1. Perguntas e respostas sobre a base de conhecimento de uma empresa

Cenário: a empresa tem centenas de páginas de manuais de funcionários, documentação técnica e perguntas frequentes, e os novos colaboradores têm dificuldade para encontrar as informações.

Como fazer:

• Envie todos os documentos e divida cada um por seção antes de armazenar os blocos no Vectorize
• Crie uma interface web simples ou faça a integração com o bot corporativo
• O funcionário pergunta diretamente “qual é o processo de reembolso?” e o sistema encontra a seção relevante para responder

Benefício: disponibilidade 24 horas por dia e muito mais rapidez do que procurar manualmente nos documentos.

2. Atendimento inteligente

Cenário: um e-commerce tem muitas informações de produtos e políticas de pós-venda, e a equipe de atendimento responde repetidamente às mesmas perguntas.

Como fazer:

• Armazene perguntas frequentes, descrições de produtos e políticas de troca e devolução
• Quando o usuário fizer uma pergunta, deixe o sistema RAG responder primeiro
• Encaminhe para uma pessoa apenas as perguntas que o sistema não conseguir responder

Resultado: um desenvolvedor usou essa solução para reduzir em mais de 60% a carga da equipe de atendimento.

3. Assistente de anotações pessoais

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

Cenário: você mantém anotações no Notion ou Obsidian há anos e quer localizar rapidamente um conceito.

Como fazer:

• Exporte as notas periodicamente e adicione-as ao sistema RAG por API
• Quando precisar, pergunte diretamente “qual era mesmo aquela dica de TypeScript que li da última vez?”
• O sistema recupera os trechos relevantes

Eu mesmo uso uma ferramenta parecida, e a eficiência para encontrar materiais melhorou bastante.

4. Ferramenta de “conversa com PDF”

Cenário: o usuário envia um arquivo PDF, como um artigo científico, contrato ou relatório, e quer extrair informações rapidamente.

Como fazer, seguindo o caso de Rohit Patil:

• O usuário envia o PDF ao R2
• O Worker lê o PDF, extrai o texto, divide-o em blocos e gera os vetores
• O usuário pode perguntar “quais são as condições de pagamento deste contrato?”

Esse caso de uso é especialmente útil para profissionais das áreas jurídica e de consultoria.

Solução de problemas comuns

Problema 1: dimensões dos vetores incompatíveis

Erro: dimension mismatch: expected 768, got 512

Causa: a dimensão definida na criação do índice do Vectorize, 768, não corresponde à dimensão produzida pelo modelo.

Solução: confira se a dimensão do índice é a mesma do modelo. O bge-base-en-v1.5 produz vetores de 768 dimensões; não use outro modelo por engano.

Problema 2: dados inconsistentes entre D1 e Vectorize

Sintoma: o ID de uma nota retornado pela consulta não existe no D1.

Causa: talvez o registro tenha sido excluído do D1, mas não do Vectorize, ou o Workflow tenha falhado.

Solução: coloque a exclusão em uma transação ou use um Workflow para garantir que os dados sejam removidos dos dois lados.

Problema 3: tempo limite do Workflow

Erro: workflow execution timeout

Causa: a vetorização de um grande volume de texto excedeu o limite de tempo do Workflow.

Solução: divida documentos grandes entre várias tarefas do Workflow ou faça o processamento em lotes.

// 分批处理
const batchSize = 10;
for (let i = 0; i < chunks.length; i += batchSize) {
  const batch = chunks.slice(i, i + batchSize);
  await c.env.RAG_WORKFLOW.create({
    params: { noteId, chunks: batch, offset: i }
  });
}

Conclusão

Vamos recapitular o que fizemos:

• Entendemos o funcionamento do RAG: a geração aumentada por recuperação funciona como uma prova com consulta para a IA, que primeiro localiza materiais e só depois responde
• Criamos uma aplicação funcional: percorremos todo o processo de um sistema de perguntas e respostas sobre anotações, da preparação do ambiente à implementação do código
• Aprendemos técnicas de otimização: divisão de texto, ajuste da recuperação e controle de custos são os detalhes que tornam a aplicação realmente utilizável
• Vimos casos de uso reais: base de conhecimento empresarial, atendimento inteligente, assistente pessoal e conversa com PDF são algumas das possibilidades práticas

A maior vantagem do conjunto da Cloudflare é a baixa barreira de entrada. Você não precisa alugar uma GPU, instalar um banco de dados nem administrar infraestrutura. A cota gratuita é mais do que suficiente para projetos pessoais e, mesmo em produção, os planos pagos custam bem menos do que manter toda a estrutura por conta própria.

Agora você pode:

1. Começar imediatamente: clone o exemplo oficial, execute wrangler dev e veja o resultado em cinco minutos
2. Integrar dados reais: importe suas notas, documentos e perguntas frequentes e avalie a qualidade da recuperação
3. Criar uma interface frontend: desenvolva uma tela simples de chat com React ou Vue, ou implante-a diretamente no Cloudflare Pages
4. Explorar outras possibilidades: experimente RAG multimodal, combinando imagens e tabelas, ou GraphRAG, com o apoio de grafos de conhecimento

O RAG é uma das arquiteturas mais úteis das aplicações de IA atuais. Dominá-lo permite criar muitas soluções interessantes. Nos meus testes, o conjunto da Cloudflare realmente resolveu vários problemas práticos.

Se você encontrar alguma dificuldade, procure ajuda no Discord da Cloudflare ou no fórum da comunidade. A comunidade é bastante ativa.