Aufbau von KI-tauglichen Vektordatensätzen für LLMs: Ein Leitfaden mit Bright Data, Google Gemini und Pinecone

Große Sprachmodelle (Large Language Models, LLMs) verändern die Art und Weise, wie wir auf Informationen zugreifen und intelligente Anwendungen entwickeln. Um ihr volles Potenzial auszuschöpfen, insbesondere bei bereichsspezifischem Wissen oder geschützten Daten, ist die Erstellung hochwertiger, strukturierter Vektordatensätze entscheidend. Die Leistung und Genauigkeit eines LLM hängt direkt von der Qualität der Eingabedaten ab. Schlecht aufbereitete Datensätze können zu minderwertigen Ergebnissen führen, während gut kuratierte Datensätze ein LLM in einen echten Domänenexperten verwandeln können.

In diesem Leitfaden wird Schritt für Schritt gezeigt, wie man eine automatisierte Pipeline für die Erstellung von KI-fähigen Vektordatensätzen aufbaut.

Die Herausforderung: Beschaffung und Aufbereitung von Daten für LLMs

LLMs werden zwar auf riesigen Allzweck-Textkorpora trainiert, sind aber oft unzureichend, wenn sie auf spezifische Aufgaben oder Bereiche angewendet werden, z. B. bei der Beantwortung produktbezogener Anfragen, der Analyse von Branchennachrichten oder der Interpretation von Kundenfeedback. Um sie wirklich nützlich zu machen, benötigen Sie hochwertige Daten, die auf Ihren Anwendungsfall zugeschnitten sind.

Diese Daten sind in der Regel über das Web verteilt, hinter komplexen Website-Strukturen versteckt oder durch Anti-Bot-Maßnahmen geschützt.

Unser automatisierter Arbeitsablauf löst dieses Problem mit einer optimierten Pipeline, die die schwierigsten Teile der Datensatzerstellung übernimmt:

• Extraktion von Webdaten. Nutzt Bright Data zur Datenextraktion in großem Umfang und nutzt deren KI-fokussierte Infrastruktur, um Herausforderungen wie CAPTCHAs und IP-Sperren zu umgehen.
• Datenstrukturierung. Verwendet Google Gemini zum Parsen, Bereinigen und Konvertieren von Rohinhalten in gut strukturiertes JSON.
• Semantische Einbettung. Wandelt Text in Vektoreinbettungen um, die eine umfangreiche kontextuelle Bedeutung erfassen.
• Speicherung und Abruf. Indiziert Vektoren in Pinecone, einer schnellen und skalierbaren semantischen Suchdatenbank.
• KI-geeignete Ausgabe. Erzeugt hochwertige Datensätze, die für Feinabstimmung, RAG oder andere domänenspezifische KI-Anwendungen geeignet sind.

Überblick über die Kerntechnologien

Bevor wir die Pipeline aufbauen, werfen wir einen kurzen Blick auf die beteiligten Kerntechnologien und darauf, wie jede einzelne den Workflow unterstützt.

Helle Daten: Skalierbare Web-Datenerfassung

Der erste Schritt bei der Erstellung eines KI-fähigen Vektordatensatzes ist die Sammlung relevanter und hochwertiger Quelldaten. Ein Teil davon kann aus internen Systemen wie Wissensdatenbanken oder Dokumentationen stammen, ein großer Teil wird jedoch häufig aus dem öffentlichen Internet bezogen.

Moderne Websites verwenden jedoch ausgeklügelte Anti-Bot-Mechanismen wie CAPTCHAs, IP-Ratenbegrenzung und Browser-Fingerprinting, die das Scraping in großem Umfang erschweren.

Bright Data löst diese Herausforderung mit seiner Web Unlocker API, die die Komplexität der Datenerfassung abstrahiert. Sie übernimmt automatisch die Proxy-Rotation, das Lösen von CAPTCHAs und die Browser-Emulation, sodass Sie sich ganz auf die Daten konzentrieren können und nicht darauf, wie Sie auf sie zugreifen.

Google Gemini: Intelligente Umwandlung von Inhalten

Gemini ist eine Familie von leistungsstarken multimodalen KI-Modellen, die von Google entwickelt wurden und sich durch das Verstehen und Verarbeiten verschiedener Arten von Inhalten auszeichnen. In unserer Datenextraktionspipeline erfüllt Gemini drei wichtige Funktionen:

1. Parsing von Inhalten: Verarbeitet rohen HTML- oder vorzugsweise bereinigten Markdown-Inhalt.
2. Extraktion von Informationen: Identifiziert und extrahiert spezifische Datenpunkte auf der Grundlage eines vordefinierten Schemas.
3. Strukturierung der Daten: Die extrahierten Informationen werden in ein sauberes, strukturiertes JSON-Format umgewandelt.

Dieser KI-gestützte Ansatz bietet große Vorteile gegenüber herkömmlichen Methoden, die auf brüchigen CSS-Selektoren oder anfälligen regulären Ausdrücken beruhen, insbesondere in Anwendungsfällen wie z. B.:

• Dynamische Webseiten – Seiten, bei denen sich das Layout oder das DOM häufig ändert (häufig bei eCommerce-Websites, Nachrichtenportalen und anderen schnellen Domains).
• Unstrukturierte Inhalte: Extrahieren strukturierter Daten aus langen oder schlecht organisierten Textblöcken.
• Komplexe Parsing-Logik: Sie müssen keine benutzerdefinierten Scraping-Regeln für jede Website oder Inhaltsvariante pflegen und debuggen.

Einen tieferen Einblick, wie KI den Datenextraktionsprozess verändert, erhalten Sie in Using AI for Web Scraping. Wenn Sie auf der Suche nach einem praktischen Tutorial sind, das Sie durch die Implementierung von Gemini in Ihren Scraping-Workflow führt, lesen Sie unseren umfassenden Leitfaden: Web Scraping mit Gemini.

Satztransformatoren: Generierung semantischer Einbettungen

Einbettungen sind dichte Vektordarstellungen von Text (oder anderen Datentypen) in einem hochdimensionalen Raum. Diese Vektoren erfassen die semantische Bedeutung und ermöglichen die Darstellung ähnlicher Textstücke durch Vektoren, die nahe beieinander liegen, gemessen mit Metriken wie Kosinusähnlichkeit oder euklidischer Distanz. Diese Eigenschaft ist wichtig für Anwendungen wie semantische Suche, Clustering und Retrieval-Augmented Generation (RAG), bei denen das Auffinden relevanter Inhalte von der semantischen Nähe abhängt.

Die Sentence Transformers-Bibliothek bietet eine einfach zu bedienende Schnittstelle zur Erzeugung hochwertiger Satz- und Absatzeinbettungen. Sie baut auf Hugging Face Transformers auf und unterstützt eine breite Palette an vortrainierten Modellen, die auf semantische Aufgaben abgestimmt sind.

Eines der beliebtesten und effektivsten Modelle in diesem Ökosystem ist der all-MiniLM-L6-v2. Hier ist der Grund, warum er sich von anderen unterscheidet:

• Architektur: Basierend auf der MiniLM-Architektur, optimiert für Geschwindigkeit und Größe bei gleichbleibend hoher Leistung.
• Einbettungsdimension: Bildet die Eingaben auf einen 384-dimensionalen Vektorraum ab und ist damit sowohl effizient als auch kompakt.
• Ziel der Ausbildung: Feinabstimmung auf über 1 Milliarde Satzpaare unter Verwendung eines kontrastiven Lernansatzes zur Verbesserung des semantischen Verständnisses.
• Leistung: Liefert modernste oder nahezu modernste Ergebnisse bei Aufgaben wie Satzähnlichkeit, semantisches Clustering und Information Retrieval.
• Eingabelänge: Verarbeitet bis zu 256 Wortteile (Token), wobei längerer Text automatisch abgeschnitten wird – ein wichtiger Aspekt beim Chunking von Text.

Während größere Modelle vielleicht etwas nuanciertere Einbettungen bieten, bietet all-MiniLM-L6-v2 ein außergewöhnliches Gleichgewicht zwischen Leistung, Effizienz und Kosten. Seine 384-dimensionalen Vektoren sind:

• Schneller zu berechnen.
• Weniger ressourcenintensiv.
• Leichtere Speicherung und Indexierung.

Für die meisten praktischen Anwendungsfälle, insbesondere in der frühen Entwicklungsphase oder in Umgebungen mit eingeschränkten Ressourcen, ist dieses Modell mehr als ausreichend. Die geringfügigen Einbußen bei der Genauigkeit in Grenzfällen werden in der Regel durch den erheblichen Gewinn an Geschwindigkeit und Skalierbarkeit aufgewogen. Es wird daher empfohlen, bei der Erstellung der ersten Iteration Ihrer KI-Anwendung oder bei der Optimierung der Leistung auf einer bescheidenen Infrastruktur das Modell all-MiniLM-L6-v2 zu verwenden.

Pinecone: Speichern und Durchsuchen von Vektoreinbettungen

Sobald Text in Vektoreinbettungen umgewandelt wurde, benötigen Sie eine spezielle Datenbank, um diese effizient zu speichern, zu verwalten und abzufragen. Herkömmliche Datenbanken sind dafür nicht ausgelegt.Vektordatenbanken wurden speziell für die hochdimensionale Natur von Einbettungsdaten entwickelt und ermöglichen eine Ähnlichkeitssuche in Echtzeit, die für RAG-Pipelines, semantische Suche, Personalisierung und andere KI-gesteuerte Anwendungen unerlässlich ist.

Pinecone ist eine beliebte Vektordatenbank, die für ihre entwicklerfreundliche Oberfläche, ihre Suchleistung mit geringer Latenz und ihre vollständig verwaltete Infrastruktur bekannt ist. Pinecone verwaltet effizient die Komplexität der Vektorindizierung und -suche in großem Maßstab und abstrahiert die Feinheiten der Vektorsuchinfrastruktur. Zu den wichtigsten Komponenten gehören:

• Indizes: Speicherbehälter für Ihre Vektoren.
• Vektoren: Die eigentlichen Einbettungen mit zugehörigen Metadaten.
• Sammlungen: Statische Snapshots von Indizes für Backup und Versionierung.
• Namespaces: Datenpartitionierung innerhalb eines Index für Mandantenfähigkeit.

Pinecone bietet zwei Bereitstellungsarchitekturen: Serverless und Pod-basiert. Für die meisten Anwendungsfälle, insbesondere für den Einstieg oder bei dynamischen Lasten, ist Serverless aufgrund seiner Einfachheit und Kosteneffizienz die empfohlene Option.

Einrichtung & Voraussetzungen

Stellen Sie vor dem Aufbau der Pipeline sicher, dass die folgenden Komponenten richtig konfiguriert sind.

Voraussetzungen

• Python 3.9 oder höher muss auf Ihrem System installiert sein
• Erfassen Sie die folgenden API-Anmeldeinformationen

  :Polylang-Platzhalter nicht ändern

Anweisungen zur Erstellung der einzelnen API-Schlüssel finden Sie in den Abschnitten zur werkzeugspezifischen Einrichtung weiter unten.

Erforderliche Bibliotheken installieren

Installieren Sie die wichtigsten Python-Bibliotheken für dieses Projekt:

pip install requests python-dotenv google-generativeai sentence-transformers pinecone

Diese Bibliotheken bieten:

• requests: Ein beliebter HTTP-Client für die Interaktion mit APIs(requests guide)
• python-dotenv: Sicheres Laden von API-Schlüsseln aus Umgebungsvariablen
• google-generativeai: Offizielles Gemini SDK von Google (unterstützt auch JavaScript, Go und andere Sprachen)
• Satz-Transformatoren: Vorgefertigte Modelle zur Erzeugung semantischer Vektoreinbettungen
• Pinecone: SDK für die Vektordatenbank von Pinecone(Sprach-SDKs verfügbar für Python, Node.js, Go und mehr)

Umgebungsvariablen konfigurieren

Erstellen Sie eine .env-Datei im Stammverzeichnis Ihres Projekts und fügen Sie Ihre API-Schlüssel hinzu:

BRIGHT_DATA_API_KEY="your_bright_data_api_key_here"
GEMINI_API_KEY="your_gemini_api_key_here"
PINECONE_API_KEY="your_pinecone_api_key_here"

Helles Daten-Setup

So verwenden Sie den Web Unlocker von Bright Data:

1. Ein API-Token erstellen
2. Einrichten einer Web Unlocker-Zone über Ihr Bright Data-Dashboard

Beispiele für die Implementierung und Integrationscode finden Sie im Web Unlocker GitHub Repo.

Wenn Sie immer noch Lösungen vergleichen, bietet dieser Vergleich von KI-Scraping-Tools einen Einblick, wie Bright Data im Vergleich zu anderen Plattformen abschneidet.

Gemini-Einrichtung

So erzeugen Sie einen Gemini-API-Schlüssel:

1. Gehen Sie zu Google AI Studio
2. Klicken Sie auf “+ API-Schlüssel erstellen”.
3. Kopieren Sie den Schlüssel und bewahren Sie ihn sicher auf.

Tipp: Die kostenlose Stufe ist für die Entwicklung und für Tests in kleinem Umfang ausreichend. Für den produktiven Einsatz, bei dem Sie möglicherweise einen höheren Durchsatz (RPM/RPD), größere Token-Fenster (TPM) oder Datenschutz auf Unternehmensniveau und Zugriff auf erweiterte Modelle benötigen, beachten Sie die Tarifgrenzen und Preispläne.

Tannenzapfen-Setup

1. Anmeldung bei Pinecone.io
2. Kopieren Sie Ihren API-Schlüssel aus dem Dashboard
3. Um einen neuen index

   :Polylang-Platzhalter

   zu erstellen

   , ändern Sie nicht

Sobald die Einrichtung abgeschlossen ist, wird der Index mit einem grünen Status und anfänglich null Datensätzen angezeigt.

Aufbau der Pipeline: Schritt-für-Schritt-Umsetzung

Nachdem nun die Voraussetzungen konfiguriert sind, können wir unsere Datenpipeline anhand der MacBook Air M1-Produktbewertungen von Walmart als praktisches Beispiel erstellen.

Schritt 1: Datenerfassung mit Bright Data Web Unlocker

Die Grundlage unserer Pipeline besteht darin, rohe HTML-Inhalte von Ziel-URLs abzurufen. Der Web Unlocker von Bright Data zeichnet sich dadurch aus, dass er die ausgeklügelten Anti-Scraping-Maßnahmen umgeht, die von E-Commerce-Websites wie Walmart häufig eingesetzt werden.

Beginnen wir mit dieser Implementierung zum Abrufen von Webseiteninhalten:

import requests
import os
from dotenv import load_dotenv

# Load API key from environment
load_dotenv()
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

def fetch_page(url: str) -> str:
    """Fetch page content using Bright Data Web Unlocker (Markdown format)"""
    try:
        response = requests.post(
            "https://api.brightdata.com/request",
            headers={
                "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}",
                "Content-Type": "application/json",
            },
            json={
                "zone": "web_unlocker2",
                "url": url,
                "format": "raw",
                "data_format": "markdown",  # Direct HTML-to-Markdown conversion
            },
            timeout=60,
        )

        if response.status_code == 200 and len(response.text) > 1000:
            return response.text

    except Exception as e:
        print(f"Request failed: {str(e)}")

    return None

# Example usage
walmart_url = "https://www.walmart.com/reviews/product/609040889?page=1"
page_content = fetch_page(walmart_url)

if page_content:
    print(f"Success! Retrieved {len(page_content)} characters")
else:
    print("Failed to fetch page")

Warum Markdown anstelle von Roh-HTML verwenden? In unserer Pipeline fordern wir Inhalte im Markdown-Format(data_format: 'markdown') aus mehreren wichtigen Gründen an. Markdown entfernt HTML-Tags, Styling und andere Störfaktoren, wodurch die Komplexität reduziert wird und nur der wesentliche Inhalt übrig bleibt. Dies führt zu einer deutlich geringeren Anzahl von Token, wodurch die LLM-Verarbeitung effizienter wird. Außerdem bleibt die semantische Struktur in einem saubereren, besser lesbaren Format erhalten, was sowohl die Übersichtlichkeit als auch die Verarbeitungsgeschwindigkeit erhöht. Vorgänge wie die Erzeugung von Einbettungen und die Vektorindizierung werden schneller und leichter.

Weitere Informationen darüber, warum moderne KI-Agenten Markdown bevorzugen, finden Sie unter Why Are the New AI Agents Choosing Markdown Over HTML.

Schritt 2: Handhabung der Paginierung

Walmart verteilt die Produktbewertungen auf zahlreiche Seiten. Um vollständige Datensätze zu erfassen, sollten Sie eine Paginierung implementieren. Das müssen Sie:

1. Erstellen Sie die richtige Seiten-URL (?page=1, ?page=2, etc.)
2. Holen Sie den Inhalt für jede Seite
3. Erkennen, ob es eine “nächste Seite” gibt oder nicht
4. Fortfahren, bis keine Seiten mehr verfügbar sind

Hier ist eine einfache Paginierungsschleife, die den Inhalt so lange abruft, bis kein Verweis auf Seite=n+1 gefunden wird:

current_page = 1

while True:
    url = f"https://www.walmart.com/reviews/product/609040889?page={current_page}"
    page_content = fetch_page(url)

    if not page_content:
        print(f"Stopping at page {current_page}: fetch failed or no content.")
        break

    # Do something with the fetched content here
    print(f"Fetched page {current_page}")

    # Check for presence of next page reference
    if f"page={current_page + 1}" not in page_content:
        print("No next page found. Ending pagination.")
        break

    current_page += 1

Schritt 3: Extraktion strukturierter Daten mit Google Gemini

Mit dem sauberen Markdown-Inhalt aus dem vorherigen Schritt werden wir nun Google Gemini verwenden, um spezifische Informationen aus den Bewertungen zu extrahieren und sie als JSON zu strukturieren. Dadurch wird unstrukturierter Text in organisierte Daten umgewandelt, die unsere Vektordatenbank effizient indizieren kann.

Wir werden das Modell gemini-2.0-flash verwenden, das für unseren Anwendungsfall beeindruckende Spezifikationen bietet:

• Eingabekontext: 1.048.576 Token
• Ausgabegrenze: 8.192 Token
• Multimodale Unterstützung: Text, Code, Bilder, Audio und Video

In unserem Fall enthält der Markdown-Text der Walmart-Bewertungsseite in der Regel etwa 3.000 Token, was weit unter dem Limit des Modells liegt. Das bedeutet, dass wir die gesamte Seite auf einmal senden können, ohne sie in kleinere Abschnitte aufzuteilen.

Wenn Ihre Dokumente den Umfang des Kontextfensters überschreiten, müssen Sie Strategien zum Chunking anwenden. Aber für typische Webseiten macht die Kapazität von Gemini dies unnötig.

Hier ist ein Beispiel für eine Python-Funktion, die Gemini verwendet, um Bewertungen in einem strukturierten JSON-Format zu extrahieren:

import google.generativeai as genai
import json

# Initialize Gemini with JSON output configuration
model = genai.GenerativeModel(
    model_name="gemini-2.0-flash",
    generation_config={"response_mime_type": "application/json"},
)

def extract_reviews(markdown: str) -> list[dict]:
    """Extract structured review data from Markdown using Gemini."""
    prompt = f"""
    Extract all customer reviews from this Walmart product page content.
    Return a JSON array of review objects with the following structure:

    {{
      "reviews": [
        {{
          "date": "YYYY-MM-DD or original date format if available",
          "title": "Review title/headline",
          "description": "Review text content",
          "rating": <integer from 1–5>
        }}
      ]
    }}

    Rules:
    - Include all reviews found on the page
    - Use null for any missing fields
    - Convert ratings to integers (1–5)
    - Extract the full review text, not just snippets
    - Preserve original review text without summarizing

    Here's the page content:
    {markdown}
    """

    response = model.generate_content(prompt)
    result = json.loads(response.text)

    # Normalize and clean results
    return [
        {
            "date": review.get("date"),
            "title": review.get("title"),
            "description": review.get("description", "").strip(),
            "rating": review.get("rating"),
        }
        for review in result.get("reviews", [])
    ]

Promptes Engineering ist bei der Arbeit mit LLMs entscheidend. In unserer Implementierung setzen wir response_mime_type: ” application/json" ein, um sicherzustellen, dass Gemini gültiges JSON zurückgibt, wodurch die Notwendigkeit einer komplexen Textanalyse entfällt. Die Eingabeaufforderung selbst ist sorgfältig entworfen, um Halluzinationen zu reduzieren, indem Gemini angewiesen wird, sich ausschließlich auf den bereitgestellten Inhalt zu verlassen. Außerdem wird ein striktes JSON-Schema für strukturelle Konsistenz durchgesetzt, der vollständige Bewertungstext wird ohne Zusammenfassung beibehalten, und fehlende Felder werden elegant behandelt.

Nach der Bearbeitung einer Walmart-Bewertungsseite erhalten Sie strukturierte Daten wie diese:

[
  {
    "date": "Apr 13, 2025",
    "title": "Better than buying OPEN BOX",
    "description": "I bought an older product OPEN BOX (which I consider UNUSED) from another website. The battery was dead. Walmart offered NEW at a lower price. WOW!!!!",
    "rating": 5
  },
  {
    "date": "Dec 8, 2024",
    "title": "No support",
    "description": "The young man who delivered my laptop gave me the laptop with no receipt or directions. I asked where my receipt and some kind of manual were. He said it would be under my purchases. I would happily change this review if I knew where to go for help and support. The next day I went to the electronics department for help, and he had no idea.",
    "rating": 3
  }
  // ... more reviews
]

Ein funktionierendes Beispiel, das alle Schritte (Abrufen, Verarbeiten und Extrahieren) kombiniert, finden Sie in der vollständigen Implementierung auf GitHub.

Schritt 4: Generierung von Vektoreinbettungen mit Satztransformatoren

Mit sauberen, strukturierten Bewertungsdaten im JSON-Format erzeugen wir nun semantische Vektoreinbettungen für jede Bewertung. Diese Einbettungen werden für nachgelagerte Aufgaben wie semantische Suche oder Indizierung in einer Vektordatenbank wie Pinecone verwendet.

Um den vollständigen Kontext einer Kundenrezension zu erfassen, kombinieren wir den Titel und die Beschreibung der Rezension vor der Einbettung zu einer einzigen Zeichenfolge. Auf diese Weise kann das Modell sowohl die Stimmung als auch das Thema besser erfassen.

Hier ist der Beispielcode:

from sentence_transformers import SentenceTransformer

# Load the embedding model
model = SentenceTransformer("all-MiniLM-L6-v2")

def generate_embeddings(reviews):
    """Generate 384-dimensional vector embeddings from review titles and descriptions."""
    texts = []
    valid_indices = []

    # Combine title and description into a single string for embedding
    for idx, review in enumerate(reviews):
        text_parts = []
        if review.get("title"):
            text_parts.append(f"Review Title: {review['title']}")
        if review.get("description"):
            text_parts.append(f"Review Description: {review['description']}")

        if text_parts:
            texts.append(". ".join(text_parts))
            valid_indices.append(idx)

    # Generate embeddings using batch processing
    embeddings = model.encode(
        texts, show_progress_bar=True, batch_size=32, convert_to_numpy=True
    ).tolist()

    # Attach embeddings back to original review objects
    for emb_idx, review_idx in enumerate(valid_indices):
        reviews[review_idx]["embedding"] = embeddings[emb_idx]

    return reviews

Was dieser Code bewirkt:

1. Modell-Initialisierung: Lädt das All-MiniLM-L6-v2-Modell, das 384-dimensionale dichte Einbettungen liefert.
2. Vorbereitung der Eingabe: Kombiniert den Titel und die Beschreibung jeder Rezension zu einer einzigen Zeichenfolge.
3. Batch-Kodierung: Verwendet model.encode() mit Batching für effiziente Verarbeitung

   : Polylang-Platzhalter nicht ändern

4. Einbettung Injektion: Verbindet jeden Vektor mit dem entsprechenden Überprüfungsobjekt unter dem Schlüssel "embedding".

Wichtiger Hinweis: Pinecone unterstützt keine Nullwerte in Metadaten. Wenn ein Feld fehlt, müssen Sie den Schlüssel beim Hochladen zu Pinecone vollständig auslassen. Verwenden Sie keine "N/A" oder leeren Zeichenfolgen, es sei denn, sie haben eine besondere Bedeutung für Ihre Filterlogik.

Die Bereinigungsfunktion wird hier zwar nicht gezeigt (um den Code lesbar zu halten), aber die endgültige Implementierung wird die Bereinigung der Metadaten vor der Aufnahme beinhalten.

Nach der Erzeugung der Einbettung enthält jedes Bewertungsobjekt einen 384-dimensionalen Vektor:

{
  "date": "Apr 9, 2024",
  "title": "Amazing Laptop!",
  "description": "This M1 MacBook Air is incredibly fast and the battery lasts forever.",
  "rating": 5,
  "embedding": [0.0123, -0.0456, 0.0789, ..., 0.0345]  // 384 dimensions
}

Nach der Erstellung der Einbettungen sind unsere Bewertungen bereit für die Vektorspeicherung in Pinecone.

Schritt 5: Speicherung von Einbettungen und Metadaten in Pinecone

Der letzte Schritt in unserer Pipeline ist das Hochladen der eingebetteten Bewertungen in Pinecone.

Hier ist der Python-Code zum Hochladen von Daten in Pinecone:

import uuid
from pinecone import Pinecone, Index

# Initialize Pinecone client with your API key
pc = Pinecone(api_key="PINECONE_API_KEY")
index = pc.Index("brightdata-ai-dataset")  # Replace with your actual index name

# Sample review data (with embeddings already attached)
reviews_with_embeddings = [
    {
        "date": "Apr 9, 2024",
        "title": "Amazing Laptop!",
        "description": "This M1 MacBook Air is incredibly fast and the battery lasts forever.",
        "rating": 5,
        "embedding": [0.0123, -0.0456, ..., 0.0789],  # 384-dimensional vector
    }
    # ... more reviews
]

# Prepare vector records for upload
vectors = []
for review in reviews_with_embeddings:
    if "embedding" not in review:
        continue  # Skip entries without embeddings

    vectors.append(
        {
            "id": str(uuid.uuid4()),  # Unique vector ID
            "values": review["embedding"],
            "metadata": {
                "title": review.get("title"),
                "description": review.get("description"),
                "rating": review.get("rating"),
                # Add more metadata fields if needed
            },
        }
    )

# Batch upload to Pinecone (100 vectors per request)
for i in range(0, len(vectors), 100):
    batch = vectors[i : i + 100]
    index.upsert(vectors=batch)

Jeder Vektor, den Sie in Pinecone einfügen, sollte Folgendes enthalten:

• id: Ein eindeutiger String-Bezeichner (erforderlich)
• Werte: Der Vektor selbst (Liste von Fließkommazahlen, z. B. 384-dimensional)
• Metadaten: Optionale Schlüssel-Wert-Paare für Filterung und Kontext (JSON-kompatibel)

Beispiel für eine Vektorstruktur:

Sobald der Upload abgeschlossen ist, wird Ihr Pinecone-Index mit Überprüfungsvektoren aufgefüllt:

Ihr KI-fähiger Vektordatensatz ist nun in Pinecone gespeichert und bereit für die nächsten Schritte 🔥.

Ein funktionierendes Beispiel, das alle Schritte (Einbettungsgenerierung, Pinecone-Upload) kombiniert, finden Sie in der vollständigen Implementierung auf GitHub.

(Optional, aber empfohlen) Verwendung des AI-Ready-Datensatzes

Da Ihre Einbettungen nun in Pinecone indiziert sind, können Sie Anwendungen wie semantische Suche und RAG-Systeme nutzen. Dieser Schritt zeigt, wie Sie Ihre Vektordatenbank abfragen und intelligente Antworten erzeugen.

Semantische Suche

Der einfachste Weg, Ihren vektorisierten Datensatz zu nutzen, ist die semantische Suche. Anders als bei der Stichwortsuche können Nutzer bei der semantischen Suche in natürlicher Sprache Abfragen stellen und konzeptionell ähnliche Inhalte abrufen, auch wenn sie nicht dieselben Wörter enthalten.

Testen wir das System mit Abfragen in natürlicher Sprache:

queries = [
    "good price for students",
    "lightweight and good for travel",
]

Für die Abfrage “günstiger Preis für Studenten”, könnten Sie sehen:

#1 (Score: 0.6201)
ID: 75878bdc-8d96-416a-8292-484971c3bd61
Date: Aug 3, 2024
Rating: 5.0
Description: Just what my daughter needed for college and the price was perfect

#2 (Score: 0.5868)
ID: 758963ae-0927-4e82-bece-d098991f5a73
Date: Jun 13, 2024
Rating: 5.0
Description: The price was right. Perfect graduation present for my grandson

🙌 Es funktioniert wunderbar! Abfragen in natürlicher Sprache liefern hochrelevante Ergebnisse.

So funktioniert die semantische Suche:

1. Einbettung der Suchanfrage: Die Suchanfrage wird in einen Vektor umgewandelt, wobei das gleiche MiniLM-L6-v2-Modell wie bei der Indexierung verwendet wird.
2. Vektorsuche: Pinecone findet die ähnlichsten Vektoren anhand der Kosinusähnlichkeit.
3. Abruf von Metadaten: Die Ergebnisse umfassen sowohl Ähnlichkeitsbewertungen als auch zugehörige Metadaten.

Eine voll funktionsfähige Implementierung finden Sie unter: Semantische Suche Client Python-Datei.

Jenseits der Suche: Retrieval Augmented Generation (RAG)

Sobald Sie eine funktionierende semantische Suche haben, sind Sie nur noch einen Schritt davon entfernt, ein LLM-gestütztes RAG-System aufzubauen. Retrieval Augmented Generation (RAG) lässt Ihr LLM geerdete Antworten unter Verwendung von externem Kontext, wie Ihrem vektorisierten Datensatz, generieren.

RAG Flow:

1. Der Benutzer stellt eine Frage (z. B. “Ist dieses MacBook für Studenten geeignet?”).
2. Die semantische Suche ruft relevante Dokumente aus Pinecone ab.
3. Der ermittelte Kontext und die Frage werden an einen LLM wie Google Gemini gesendet.
4. LLM antwortet mit den Fakten aus Ihrem Datensatz.

Beispiel für RAG-Antworten:

🤔 User: Is the battery life good for college use?
🤖 Assistant: Yes, users report long battery life—enough to last through full days of classes and study.

🤔 User: How does this compare to a Chromebook?
🤖 Assistant: One review says the MacBook Air "works so smoothly compared to a Chromebook".

Sehen Sie sich den vollständigen Code an, der für RAG und die semantische Suche verwendet wird: RAG Chatbot Implementierung.

Nächste Schritte

Sie haben erfolgreich eine vollständige Pipeline zur Erstellung von KI-fähigen Vektordatensätzen aufgebaut. Hier erfahren Sie, wie Sie Ihre Implementierung erweitern und optimieren können:

1. Skalieren Sie die Datenerfassung: Für einen umfangreicheren Datenbedarf können Sie die vollständige KI-fähige Webdateninfrastruktur von Bright Data für einen unbegrenzten, konformen Webdatenzugriff nutzen, der für KI-Modelle und -Agenten optimiert ist.
2. Experimentieren Sie mit Einbettungsmodellen: Obwohl all-MiniLM-L6-v2 effizient ist, können Sie für bestimmte Anwendungsfälle bessere Ergebnisse erzielen, wenn Sie zu größeren oder mehrsprachigen Modellen wechseln. Sie können auch die Einbettung von APIs von Google Gemini und OpenAI ausprobieren.
3. Extraktionsaufforderungen verfeinern: Passen Sie die Gemini-Eingabeaufforderung an die verschiedenen Website-Strukturen oder Datenschemata an, die Sie extrahieren müssen.
4. Nutzen Sie die erweiterten Pinecone-Funktionen: Erforschen Sie Filter, Namespaces, Metadaten-Indizierung und hybride Suche, indem Sie in die offizielle Pinecone-Dokumentation eintauchen.
5. Automatisieren Sie die Pipeline: Integrieren Sie diese Pipeline in einen Produktions-Workflow mit Tools wie Apache Airflow oder Prefect für die Orchestrierung, AWS Step Functions oder Google Cloud Workflows für die Cloud-native Planung.
6. Erstellen Sie eine KI-gestützte Anwendung: Verwenden Sie die semantische Suche oder die RAG-Komponenten, um reale Tools wie Chatbots für den Kundensupport, Wissensdatenbank-Suche und Empfehlungsmaschinen zu erstellen.

Schlussfolgerung

Sie haben erfolgreich eine vollständige, robuste Pipeline aufgebaut, die KI-fähige Vektordatensätze erstellt und verwaltet und dabei Web-Rohdaten in wertvolle Ressourcen für große Sprachmodelle verwandelt. Durch die Kombination von Bright Data für skalierbares Web Scraping, Google Gemini für intelligente strukturierte Extraktion, Sentence Transformers für die Generierung semantischer Einbettungen und Pinecone für die Speicherung und den Abruf von Vektordaten haben Sie Ihre benutzerdefinierten Daten effektiv für die Verbesserung von LLM-Anwendungen vorbereitet.

Dieser Ansatz basiert auf spezifischem Fachwissen und liefert genauere, relevante und wertvolle KI-gestützte Lösungen.