在 Cloudflare Workers 上构建 RAG 聊天机器人（Vectorize + D1 + Workflows）

export class RAGWorkflow extends WorkflowEntrypoint<Env, RagWorkflowParams> {
    async run(event: WorkflowEvent<RagWorkflowParams>, step: WorkflowStep) {
        const { data } = event.payload;

        const texts = await step.do('split text', async () => {
            // split `data` into chunks with RecursiveCharacterTextSplitter
        });

        for (const [i, text] of texts.entries()) {
            const record = await step.do(`store in D1 db: ${i}/${texts.length}`, async () => {
                // insert the chunk's text into D1, return its new row id
            });

            const vector = await step.do(`Generate Embeddings: ${i}/${texts.length}`, async () => {
                // embed the chunk's text via Workers AI (bge-base-en-v1.5)
            });

            await step.do(`Insert Vector: ${i}/${texts.length}`, async () => {
                // upsert { id: record, values: vector } into Vectorize
            });
        }
    }
}

const record = await step.do(`store in D1 db: ${i}/${texts.length}`,
 async () => { /* ... */ });

env.VECTORIZE.upsert([{ id: record.toString(), values: vector }]);

{
    "ai": { "binding": "AI" },
    "vectorize": [{ "binding": "VECTORIZE", "index_name": "vector-index" }],
    "d1_databases": [{ "binding": "database", "database_name": "database", "database_id": "..." }],
    "workflows": [{ "name": "rag", "binding": "RAG_WORKFLOW", "class_name": "RAGWorkflow" }],
    "assets": { "directory": "./public/", "binding": "ASSETS" }
}

npx wrangler vectorize create vector-index --dimensions=768 --metric=cosine

const RELEVANCE_THRESHOLD: number = 0.58;
const TOP_K: number = 3;

export function filterRelevant(matches: VectorizeMatch[], threshold = RELEVANCE_THRESHOLD) {
    return matches.filter((match) => match.score > threshold);
}

async function QueryVector(question: string, c: Context<AppEnv>) {
    const modelResp = await c.env.AI.run('@cf/baai/bge-base-en-v1.5', { text: question });
    const vector = modelResp.data[0]; // (async/queued-response guard omitted for brevity)

    let { matches } = await c.env.VECTORIZE.query(vector, { topK: TOP_K });
    matches = filterRelevant(matches);

    const notes: string[] = [];
    const citeIds: number[] = [];
    for (const match of matches) {
        // look up match.id's text in D1, push it (and its id) onto notes / citeIds
    }

    const contextMessage = notes.length ? `Context:\n${notes.map((note) => `- ${note}`).join('\n')}` : '';
    return { contextMessage, citeIds };
}

async function LlmWithRag(c: Context<AppEnv>, question: string, contextMessage: string) {
    const systemPrompt = contextMessage.length > 0
        ? `You are a helpful assistant. Answer using the context provided.\n\n${contextMessage}`
        : 'You are a helpful assistant. No relevant notes were found for this question - say so plainly rather than guessing.';

    const modelResp = await c.env.AI.run('@cf/qwen/qwen3.8-27b', {
        messages: [
            { role: 'system', content: systemPrompt },
            { role: 'user', content: question },
        ],
    });

    return modelResp.choices[0]?.message?.content; // (empty-response handling omitted for brevity)
}

app.get('/api/query', async (c) => {
    const question = c.req.query('text');
    if (!question) return c.text('specify text in ?text query', 400);

    const { contextMessage, citeIds } = await QueryVector(question, c);
    const answer = await LlmWithRag(c, question, contextMessage);

    return c.json({ llmAnswer: answer, citedNoteIds: citeIds }, 200);
});

npx wrangler d1 migrations apply database --local
cp .dev.vars.example .dev.vars   # then set a real ADMIN_TOKEN
npm run dev

# Ask a question
curl -G "http://127.0.0.1:8787/api/query" --data-urlencode "text=How long is a Personal Access Token valid for?"
# → {"llmAnswer":"...", "citedNoteIds":[3]}

# Upload a document (raw markdown as the body - no JSON wrapping needed for a single field)
curl -X POST http://127.0.0.1:8787/admin/ingest \
  -H "Content-Type: text/markdown" \
  -H "Authorization: Bearer $ADMIN_TOKEN" \
  --data-binary @my-notes.md
# → {"message":"Ingestion started"}

# List everything currently ingested
curl -H "Authorization: Bearer $ADMIN_TOKEN" http://127.0.0.1:8787/admin/notes

# Delete a chunk from both D1 and Vectorize
curl -X DELETE -H "Authorization: Bearer $ADMIN_TOKEN" http://127.0.0.1:8787/admin/notes/3

formEl.addEventListener('submit', async (e) => {
    e.preventDefault();
    const question = inputEl.value.trim();
    if (!question) return;
    inputEl.value = '';
    addMessage('user', question);

    submitBtn.disabled = true;
    try {
        const response = await fetch('/api/query?' + new URLSearchParams({ text: question }));
        if (!response.ok) {
            addMessage('assistant error', `Request failed (${response.status})`);
            return;
        }
        const { llmAnswer, citedNoteIds } = await response.json();
        addMessage('assistant', `${llmAnswer}\n\n (from note #${citedNoteIds.join(', ')})`);
    } finally {
        submitBtn.disabled = false;
    }
});