KI-Wissensdatenbank in 20 Minuten? Workers AI + Vectorize: Schritt-für-Schritt-RAG-Anleitung (mit vollständigem Code)

Sie wollen einen intelligenten Kundenservice für Ihr Unternehmen, stöbern in RAG-Tutorials – und finden entweder theoretische Erklärungen ohne Ende oder Anleitungen, die mit GPU-Miete und Umgebungsaufbau beginnen. Allein LangChain und Vektordatenbank zu konfigurieren kann zwei Tage dauern – und am Ende läuft es trotzdem nicht.

Dann entdecken Sie: Cloudflare bietet ein komplettes KI-Toolkit – Workers AI + Vectorize + D1, vollständig verwaltet, mit großzügigem Free-Tier. Ich habe damit eine Notiz-Q&A-App gebaut: von null bis lauffähig in unter 20 Minuten, mit etwa hundert Zeilen Code.

Dieser Artikel führt Sie Schritt für Schritt durch den gesamten Ablauf:

• RAG verständlich erklärt – ohne Fachchinesisch, in klaren Worten
• Praxis: eine lauffähige Wissensdatenbank-Q&A-App (mit vollständigem Code)
• Optimierung: genaueres Retrieval, niedrigere Kosten
• Deployment: wirklich produktiv nutzen

Sie brauchen etwas JavaScript, ein kostenloses Cloudflare-Konto – und können mitmachen.

Was ist RAG? Funktionsweise in 5 Minuten

RAG anhand einer Prüfung verstehen

Zuerst eine anschauliche Analogie. Bei einer Klausur ohne Unterlagen können Sie nur antworten, was Sie im Kopf haben – vergessen Sie etwas, raten Sie. Bei einer offenen Prüfung schlagen Sie im Buch nach – die Antworten werden deutlich genauer.

RAG (Retrieval-Augmented Generation) gibt der KI diese „offene Prüfung“.

Ein klassisches LLM ist wie eine Klausur ohne Unterlagen: Es antwortet nur aus Trainingsdaten. Probleme:

• Trainingsdaten veralten – keine aktuellen Informationen
• Ihre internen Unternehmensdokumente kennt es nicht
• Details gehen verloren – die KI erfindet (Fachbegriff: „Halluzination“)

RAG sucht zuerst in Ihrer vorbereiteten Wissensdatenbank nach relevanten Materialien und übergibt diese der KI zur Beantwortung. So sind Antworten fundiert und aktuell.

Die drei Kernschritte von RAG

Der Ablauf in drei Schritten:

Schritt 1: Wissen in Vektoren umwandeln und speichern

Sie haben eine Menge Dokumente. RAG wandelt jeden Textabschnitt in eine Zahlenfolge um (Fachbegriff: „Vektor“ oder „Embedding“). Diese Zahlen repräsentieren die Bedeutung des Textes.

„Katzen sind süß“ und „Kätzchen sind niedlich“ – unterschiedliche Worte, ähnliche Bedeutung. Als Vektoren liegen die Zahlenfolgen nahe beieinander. Die Vektoren landen in einer Vektordatenbank wie Vectorize.

Schritt 2: Bei Nutzerfragen die relevantesten Wissensfragmente finden

Fragt jemand „Wie trainiere ich eine Katze?“, wird die Frage ebenfalls vektorisiert. In der Datenbank sucht das System die „nächsten“ Abschnitte – semantisch am besten passend.

Das heißt Ähnlichkeitssuche: in Millisekunden aus Zehntausenden Einträgen die besten 3–5 Treffer.

Schritt 3: Gefundene Inhalte an das LLM übergeben

Die Treffer werden zu einem Prompt zusammengebaut:

Folgende relevante Materialien:
[Inhalt 1]
[Inhalt 2]
...
Nutzerfrage: Wie trainiere ich eine Katze?
Bitte antworten Sie auf Basis der obigen Materialien.

Mit diesen „Referenzmaterialien“ liefert die KI präzise, begründete Antworten.

Warum der Cloudflare-Stack?

Es gibt viele RAG-Ansätze – LangChain, LlamaIndex usw. –, aber eigene Umgebung, Vektordatenbank und GPU-Ressourcen kosten Nerven.

Vorteile von Cloudflare:

Workers AI – Dutzende Open-Source-Modelle (Llama 3, Claude u. a.), per API nutzbar, keine GPU-Miete. Im Free-Tier tägliches Neurons-Kontingent – für persönliche Projekte ausreichend.

Vectorize – Verwaltete Vektordatenbank, kein Milvus oder Pinecone selbst betreiben. Index anlegen, Vektoren einfügen, Ähnlichkeitssuche – wenige Zeilen Code.

D1 – Cloudflares SQLite-Datenbank für Rohtext. In der Vektordatenbank liegen nur Vektoren; den eigentlichen Text holen Sie von hier.

Alibaba Cloud - Top-Wahl für Entwickler, exklusiv 15 % Rabatt auf Lighthouse-Server

15 % Rabatt sichern →Anzeige

Vollständig verwaltet – kein Server, Skalierung, Backup. Sie schreiben Code. Cloudflares Edge-Netzwerk liefert weltweit niedrige Latenz.

"2025 führte Cloudflare AutoRAG ein: Dokumente nach R2 hochladen – Chunking, Vektorisierung, Retrieval und Generierung laufen automatisch"

2025 kam außerdem AutoRAG – Upload nach R2, der Rest automatisch. In diesem Artikel bauen wir manuell, um die Grundlagen zu verstehen.

Genug Theorie – jetzt wird gebaut.

Praxis: Ihre erste RAG-Anwendung

Wir bauen eine Notiz-Q&A-App: Nutzer fügen Notizen hinzu und stellen Fragen – das System findet relevante Inhalte und antwortet.

Projektinitialisierung und Umgebung

Zuerst Wrangler (Cloudflares CLI) installieren:

npm install -g wrangler
wrangler login  # Cloudflare-Konto anmelden

Projekt anlegen:

npm create cloudflare@latest rag-notes-app
# „Hello World“ Worker wählen
# TypeScript wählen
cd rag-notes-app

Routing-Bibliothek Hono installieren (praktischer als native Workers-API):

npm install hono

D1-Datenbank und Vectorize-Index anlegen:

# D1 für Rohtext der Notizen
wrangler d1 create notes-db
# Vectorize-Index (768 Dimensionen, Modell bge-base-en-v1.5)
wrangler vectorize create notes-index --dimensions=768 --metric=cosine

Dann wrangler.jsonc (oder wrangler.toml) konfigurieren:

{
  "name": "rag-notes-app",
  "main": "src/index.ts",
  "compatibility_date": "2024-01-01",
  "node_compat": true,
  // AI-Binding
  "ai": {
    "binding": "AI"
  },
  // D1-Datenbank-Binding
  "d1_databases": [
    {
      "binding": "DB",
      "database_name": "notes-db",
      "database_id": "Ihre-Datenbank-ID"  // aus der Ausgabe des create-Befehls
    }
  ],
  // Vectorize-Index-Binding
  "vectorize": [
    {
      "binding": "VECTORIZE",
      "index_name": "notes-index"
    }
  ],
  // Workflow-Binding (asynchrone Vektorisierung)
  "workflows": [
    {
      "binding": "RAG_WORKFLOW",
      "name": "rag-workflow",
      "class_name": "RAGWorkflow"
    }
  ]
}

Datenbanktabellen initialisieren:

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

Ausführen:

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

Wissensdatenbank: Einträge erfassen

Kern von RAG: Nutzer-Notizen in Vektoren umwandeln und speichern.

src/workflow.ts anlegen (Workflow für asynchrone Aufgaben):

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;
    // Schritt 1: D1-Eintrag bestätigen (vom Hauptrouter erstellt)
    // Schritt 2: Vektor erzeugen
    const embeddings = await step.do('generate embeddings', async () => {
      const response = await this.env.AI.run(
        '@cf/baai/bge-base-en-v1.5',  // 768-dimensionales Embedding-Modell
        { text: [text] }
      );
      return response.data[0];  // Vektor-Array zurückgeben
    });
    // Schritt 3: In Vectorize einfügen
    await step.do('insert vector', async () => {
      await this.env.VECTORIZE.insert([
        {
          id: noteId.toString(),
          values: embeddings,
          metadata: { text }  // Text für Debugging mit speichern
        }
      ]);
    });
  }
}

Hauptrouter src/index.ts (Notizen hinzufügen):

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 }>();
// Notiz hinzufügen
app.post('/notes', async (c) => {
  const { text } = await c.req.json<{ text: string }>();
  if (!text?.trim()) {
    return c.json({ error: 'Text is required' }, 400);
  }
  // In D1 einfügen
  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 für asynchrone Vektorisierung starten
  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 };

Bei POST zum Hinzufügen einer Notiz:

1. Text sofort in D1
2. Workflow erzeugt im Hintergrund Vektoren und schreibt in Vectorize
3. Vektorisierung dauert Sekunden – blockiert die Anfrage nicht

Intelligente Q&A-Funktion

Notizen sind gespeichert – jetzt die Abfrage.

In src/index.ts ergänzen:

// Q&A-Abfrage
app.get('/', async (c) => {
  const query = c.req.query('q');
  if (!query) {
    return c.json({ error: 'Query parameter "q" is required' }, 400);
  }
  // Schritt 1: Frage vektorisieren
  const queryEmbedding = await c.env.AI.run(
    '@cf/baai/bge-base-en-v1.5',
    { text: [query] }
  );
  // Schritt 2: 3 ähnlichste Notizen in Vectorize finden
  const matches = await c.env.VECTORIZE.query(
    queryEmbedding.data[0],
    { topK: 3, returnMetadata: true }
  );
  if (matches.count === 0) {
    return c.json({ answer: 'Keine relevanten Notizen gefunden' });
  }
  // Schritt 3: Volltext aus D1 (falls nötig)
  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();
  // Schritt 4: Prompt bauen, LLM aufrufen
  const context = notes.results.map((n: any) => n.text).join('\n\n---\n\n');
  const prompt = `Folgende relevante Notizinhalte:
${context}
Nutzerfrage: ${query}
Bitte antworten Sie auf Basis der obigen Notizen. Wenn keine relevanten Informationen vorhanden sind, sagen Sie das klar.`;
  const aiResponse = await c.env.AI.run(
    '@cf/meta/llama-3-8b-instruct',  // oder claude-3-5-sonnet-latest
    {
      messages: [
        { role: 'system', content: 'Sie sind ein intelligenter Notiz-Assistent' },
        { 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
    }))
  });
});

Testen:

# Lokal starten
wrangler dev
# Notiz hinzufügen
curl -X POST http://localhost:8787/notes \
  -H "Content-Type: application/json" \
  -d '{"text": "Cloudflare Workers AI unterstützt Llama 3 und Claude-Modelle"}'
curl -X POST http://localhost:8787/notes \
  -H "Content-Type: application/json" \
  -d '{"text": "Vectorize nutzt Kosinus-Ähnlichkeit für Vektor-Retrieval"}'
# Einige Sekunden warten, bis der Workflow fertig ist
# Frage stellen
curl "http://localhost:8787/?q=Welche%20Modelle%20hat%20Workers%20AI"

Bei Erfolg erhalten Sie eine Antwort auf Basis Ihrer Notizen.

Löschen und Aktualisieren

Beim Löschen auch D1 und Vectorize bereinigen:

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

Aktualisieren: am einfachsten löschen und neu anlegen (Vektor neu erzeugen).

Vollständiger Code: Cloudflare-Beispiel.

Fortgeschrittene Optimierung – RAG schlauer machen

Die Basis läuft – für den Produktiveinsatz lohnen sich diese Details.

Text-Chunking-Strategie

Aktuell speichern wir ganze Notizen als eine Einheit. Bei langen Texten (z. B. Technikdokumente) entstehen Probleme:

1. Die Gesamtähnlichkeit eines langen Dokuments kann niedrig sein (nur ein Abschnitt ist relevant)
2. Zu langer Prompt überschreitet das Kontextfenster des LLM

Besser: lange Texte in Chunks teilen, pro Chunk ein Vektor.

Einfache Chunking-Funktion:

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;  // Überlappung, damit Sätze nicht mitten durchgeschnitten werden
  }
  return chunks;
}

Intelligenter: nach Absätzen oder semantisch (z. B. LangChain RecursiveCharacterTextSplitter) – für die meisten Fälle reicht feste Länge plus Overlap.

Workflow anpassen – pro Chunk eindeutige ID:

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] }
  }]);
}

Retrieval-Genauigkeit verbessern

topK und Ähnlichkeitsschwelle anpassen

Standard top 3 kann zu wenig oder zu viel sein. Probieren Sie 5 Treffer und filtern Sie schwache:

const matches = await c.env.VECTORIZE.query(queryEmbedding.data[0], {
  topK: 5,
  returnMetadata: true
});
// Nur Ähnlichkeit > 0,7 behalten
const relevantMatches = matches.matches.filter(m => m.score > 0.7);

Score 0–1 (Kosinus-Ähnlichkeit); ab 0,7 gilt es meist als relevant.

Prompt optimieren

Nicht nur Treffer an die KI werfen – erklären, wie sie genutzt werden sollen:

KiloClaw - Managed OpenClaw für Unternehmen: AI-Agent-Orchestrierung und smartes Modell-Routing

Jetzt starten →Anzeige

const prompt = `Sie sind ein intelligenter Notiz-Assistent. Folgende Inhalte wurden aus der Notizbibliothek abgerufen (nach Relevanz sortiert):
${context}
Antworten Sie strikt auf Basis dieser Inhalte. Reichen sie nicht aus, sagen Sie klar „In den Notizen wurde nichts Relevantes gefunden“ – erfinden Sie nichts.
Nutzerfrage: ${query}`;

Wichtig:

• Klar machen: abgerufene Materialien
• Nur darauf basierend antworten
• „Weiß nicht“ ist erlaubt

Das reduziert Halluzinationen.

Kostenkontrolle und Rate Limiting

Workers AI Free-Tier hat tägliches Neurons-Limit (aktuelle Werte: Pricing-Seite).

Verbrauch überwachen:

Cloudflare Dashboard → Workers AI zeigt den Tagesverbrauch. Embedding-Modelle sind günstiger, LLM-Generierung teurer.

Degradation:

Bei Bedenken wegen Überschreitung:

1. Anfragen pro Nutzer begrenzen (KV oder Durable Objects)
2. Nach Limit kleineres Modell oder Cache
3. Für unkritische Anfragen nur Rohtext der Treffer, ohne LLM

// Einfaches Rate-Limit-Beispiel
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 });

Stärkere Modelle

Llama 3 8B ist solide; für besseres Verständnis Claude:

// Zuerst Anthropic API Key im Dashboard binden
const aiResponse = await c.env.AI.run('claude-3-5-sonnet-latest', {
  messages: [
    { role: 'system', content: 'Sie sind ein intelligenter Notiz-Assistent' },
    { role: 'user', content: prompt }
  ]
});

Claude liefert oft bessere Qualität, verbraucht aber mehr Neurons. Je nach Bedarf wählen.

Erfahrung:

• Einfache Q&A: Llama 3 reicht
• Schlussfolgerungen, Zusammenfassungen: Claude deutlich besser
• Knappes Budget: erst Llama testen, dann upgraden

Deployment und Anwendungsfälle

Deployment

Lokal getestet – Deployment in einer Zeile:

wrangler deploy

Cloudflare übernimmt:

• Code bündeln
• Deployment an Edge-Knoten weltweit
• .workers.dev-Domain

Ausgabe etwa:

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

Das ist Ihre API-URL.

Eigene Domain (optional):

Domain bei Cloudflare:

wrangler domains add api.yourdomain.com

Oder Dashboard → Workers & Pages → Ihr Worker → Settings → Domains.

Umgebungsvariablen und Secrets:

Bei Anthropic API Key oder anderen Secrets:

wrangler secret put ANTHROPIC_API_KEY
# Key eingeben

Im Code:

const apiKey = c.env.ANTHROPIC_API_KEY;

Reale Anwendungsfälle

Diese RAG-Architektur deckt viel ab – einige Beispiele:

1. Unternehmens-Wissensdatenbank

Szenario: Hunderte Seiten Handbuch, Technikdoku, FAQ – neue Mitarbeitende finden schwer.

Vorgehen:

• Dokumente hochladen, nach Kapiteln chunken, in Vectorize
• Einfache Web-Oberfläche oder Anbindung an Unternehmens-Chat
• Frage „Wie läuft die Spesenabrechnung?“ – System findet Kapitel und antwortet

Vorteil: 24/7 online, schneller als Dokumente durchsuchen.

2. Intelligenter Kundenservice

Szenario: E-Commerce mit vielen Produktdaten und Richtlinien – wiederholte Standardfragen.

Vorgehen:

• FAQ, Produktbeschreibungen, Retourenrichtlinien speichern
• RAG antwortet zuerst
• Unklare Fälle an Menschen

Effekt: Entwickler berichten von über 60 % weniger Druck auf den Support.

3. Persönlicher Notiz-Assistent

Vultr - Hochleistungs-NVMe-Cloud-Server mit 32 Standorten weltweit, Docker per Klick

Preise ansehen →Anzeige

Szenario: Jahre Notizen in Notion oder Obsidian – schnell einen Punkt wiederfinden.

Vorgehen:

• Notizen regelmäßig exportieren, per API in RAG laden
• Fragen wie „Was war nochmal der TypeScript-Trick?“
• System liefert relevante Abschnitte

Praktisch – deutlich schnelleres Auffinden.

4. „Chat with PDF“

Szenario: PDF hochladen (Paper, Vertrag, Report) und Informationen extrahieren.

Vorgehen (siehe Fallstudie von Rohit Patil):

• PDF nach R2
• Worker liest Text, chunkt, vektorisiert
• Frage: „Was sind die Zahlungsbedingungen in diesem Vertrag?“

Sehr nützlich in Recht und Beratung.

Häufige Probleme

Problem 1: Vektordimension passt nicht

Fehler: dimension mismatch: expected 768, got 512

Ursache: Index-Dimension (768) und Modellausgabe stimmen nicht überein.

Lösung: Dimension und Modell abgleichen. bge-base-en-v1.5 = 768 Dimensionen.

Problem 2: D1 und Vectorize inkonsistent

Symptom: Abfrage liefert note-ID, die in D1 fehlt.

Ursache: D1 gelöscht, Vectorize nicht – oder Workflow fehlgeschlagen.

Lösung: Löschen in Transaktion oder Workflow, der beide Seiten bereinigt.

Problem 3: Workflow-Timeout

Fehler: workflow execution timeout

Ursache: Vektorisierung großer Texte überschreitet Zeitlimit.

Lösung: Mehrere Workflow-Aufgaben oder Batch-Verarbeitung.

// Batch-Verarbeitung
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 }
  });
}

Fazit

Kurz zusammengefasst:

• RAG verstanden: Retrieval-Augmented Generation – der KI „offenes Buch“, zuerst Material, dann Antwort
• Lauffähige App: Notiz-Q&A von Umgebung bis Code
• Optimierung: Chunking, Retrieval-Tuning, Kostenkontrolle
• Anwendungsfälle: Wissensdatenbank, Kundenservice, persönlicher Assistent, PDF-Chat

Der Cloudflare-Stack punktet mit niedriger Einstiegshürde: keine GPU, keine eigene DB, kein Betrieb – Free-Tier für persönliche Projekte, Paid günstiger als Self-Hosting.

Als Nächstes:

1. Sofort starten: Offizielles Beispiel klonen, wrangler dev – in 5 Minuten sichtbar
2. Echte Daten: Notizen, Dokumente, FAQ importieren, Retrieval-Qualität prüfen
3. Frontend: React/Vue-Chat oder Cloudflare Pages
4. Mehr erkunden: Multimodales RAG, GraphRAG usw.

RAG ist eine der praktischsten KI-Architekturen – damit lassen sich viele nützliche Anwendungen bauen. Der Cloudflare-Stack löst echte Probleme.

Bei Fragen: Cloudflare Discord oder Community-Forum – aktive Community.