Wie man einen RAG-Chatbot mit GPT-Modellen und SERP-Daten erstellt

In dieser Anleitung werden Sie Folgendes erfahren:

Einen Überblick über RAG und seine Mechanismen
Die Vorteile der Integration von SERP-Daten in GPT-4o durch RAG
Wie man einen Python RAG Chatbot mit OpenAI GPT Modellen und SERP Daten implementiert

Lasst uns eintauchen!

Was ist RAG?

RAG, kurz für Retrieval-Augmented Generation, ist ein KI-Ansatz, der die Informationsbeschaffung mit der Textgenerierung kombiniert. In einem RAG-Workflow ruft die Anwendung zunächst relevante Daten aus externen Quellen ab, z. B. aus Dokumenten, Webseiten oder Datenbanken. Dann übergibt sie die Daten an die KI-Modelle, damit diese kontextbezogenere Antworten generieren können.

RAG verbessert große Sprachmodelle (LLMs) wie GPT, indem es ihnen ermöglicht, auf aktuelle Informationen jenseits ihrer ursprünglichen Trainingsdaten zuzugreifen und diese zu referenzieren. Dieser Ansatz ist in Szenarien, in denen präzise und kontextspezifische Informationen benötigt werden, von entscheidender Bedeutung, da er sowohl die Qualität als auch die Genauigkeit der von der KI generierten Antworten verbessert.

Warum sollten KI-Modelle mit SERP-Daten gefüttert werden?

Der Wissensstichtag für GPT-4o ist Oktober 2023, was bedeutet, dass es keinen Zugriff auf Ereignisse oder Informationen hat, die nach diesem Zeitpunkt veröffentlicht wurden. Die GPT-4o-Modelle können jedoch mithilfe der Bing-Suchintegration Daten in Echtzeit aus dem Internet abrufen. So können sie aktuellere Informationen anbieten.

Was aber, wenn Sie möchten, dass das KI-Modell bestimmte Datenquellen verwendet oder zuverlässigere Suchmaschinen bevorzugt? Hier kommt RAG ins Spiel!

Insbesondere die Einspeisung von SERP-Daten(Search Engine Results Page) in KI-Modelle über RAG ist eine gute Möglichkeit, um bessere Antworten zu erhalten. Dieser Ansatz ist besonders vorteilhaft für Aufgaben, die aktuelle Informationen oder spezielle Erkenntnisse erfordern.

Kurz gesagt, die Weitergabe von Daten aus hochrangigen Suchergebnissen an GPT-4o oder GPT-4o mini führt zu detaillierten, präzisen und kontextreichen Antworten.

RAG mit SERP-Daten und GPT-Modellen mit Python: Schritt-für-Schritt-Tutorial

In diesem Tutorial lernen Sie, wie Sie einen RAG-Chatbot mit den GPT-Modellen von OpenAI erstellen können. Die Idee ist, Text von den Seiten zu sammeln, die bei Google für eine bestimmte Suchanfrage am besten abschneiden, und ihn als Kontext für eine GPT-Anfrage zu verwenden.

Die größte Herausforderung ist das Sammeln von SERP-Daten. Der Grund dafür ist, dass die meisten Suchmaschinen über fortschrittliche Anti-Bot-Lösungen verfügen, um den automatischen Zugriff auf ihre Seiten zu verhindern. Eine ausführliche Anleitung finden Sie in unserem Leitfaden zum Scrapen von Google in Python.

Um den Scraping-Prozess zu vereinfachen, werden wir die SERP-API von Bright Data verwenden:

Mit diesem Premium-SERP Scraper können Sie ganz einfach SERPs von Google, DuckDuckGo, Bing, Yandex, Baidu und anderen Suchmaschinen über einfache HTTP-Anfragen abrufen.

Anschließend werden wir mit einem Headless-Browser Textdaten aus den zurückgegebenen URLs extrahieren. Anschließend werden wir diese Informationen als Kontext für das GPT-Modell in einem RAG-Workflow verwenden. Wenn Sie stattdessen Online-Daten direkt mit KI abrufen möchten, lesen Sie unseren Artikel über Web-Scraping mit ChatGPT.

Wenn Sie den Code erforschen möchten oder ihn bei der Ausführung der folgenden Schritte zur Hand haben wollen, klonen Sie das GitHub-Repository, das diesen Artikel unterstützt:

git clone https://github.com/Tonel/rag_gpt_serp_scraping

Folgen Sie den Anweisungen in der Datei README.md, um die Abhängigkeiten des Projekts zu installieren und das Projekt zu starten.

Beachten Sie, dass der in diesem Blogbeitrag vorgestellte Ansatz leicht an jede andere Suchmaschine oder LLM angepasst werden kann.

Hinweis: Diese Anleitung bezieht sich auf Unix und macOS. Wenn Sie ein Windows-Benutzer sind, können Sie dem Tutorial trotzdem folgen, indem Sie das Windows Subsystem für Linux (WSL) verwenden.

Schritt #1: Initialisieren eines Python-Projekts

Stellen Sie sicher, dass Sie Python 3 auf Ihrem Rechner installiert haben. Andernfalls laden Sie es herunter und installieren es.

Erstellen Sie einen Ordner für Ihr Projekt und geben Sie ihn im Terminal ein:

mkdir rag_gpt_serp_scraping

cd rag_gpt_serp_scraping

Der Ordner rag_gpt_serp_scraping wird Ihr Python-RAG-Projekt enthalten.

Laden Sie dann das Projektverzeichnis in Ihre bevorzugte Python-IDE. PyCharm Community Edition oder Visual Studio Code mit der Python-Erweiterung sind ausreichend.

Fügen Sie innerhalb von rag_gpt_serp_scraping eine leere app.py-Datei hinzu. Diese wird Ihre Scraping- und RAG-Logik enthalten.

Als nächstes initialisieren Sie eine virtuelle Python-Umgebung im Projektverzeichnis:

python3 -m venv env

Aktivieren Sie die virtuelle Umgebung mit dem folgenden Befehl:

source ./env/bin/activate

Großartig! Sie sind nun vollständig eingerichtet.

Schritt #2: Installieren Sie die benötigten Bibliotheken

Die von diesem auf GPT-Modellen basierenden Python-RAG-Projekt benötigten Bibliotheken sind:

python-dotenv: Zum Laden von Umgebungsvariablen aus einer .env-Datei. Sie wird für die sichere Verwaltung sensibler Anmeldeinformationen wie Bright Data-Anmeldeinformationen und OpenAI API-Schlüssel verwendet.
Anfragen: Zum Ausführen von HTTP-Anforderungen an die SERP-API von Bright Data. Weitere Informationen finden Sie in unserem Leitfaden zur Verwendung eines Proxys mit Requests.
Langchain-Gemeinschaft: Dies ist ein Teil des LangChain-Frameworks, einer Reihe von Tools zur Erstellung von LLMs durch Verkettung interoperabler Komponenten. Es wird verwendet, um Text von den Google SERP-Seiten abzurufen und ihn zu bereinigen, um relevante Inhalte für RAG zu generieren.
openai: Die offizielle Python-Client-Bibliothek für die OpenAI API. Sie wird als Schnittstelle zu GPT-Modellen verwendet, um natürlichsprachliche Antworten auf der Grundlage der gegebenen Eingaben und des RAG-Kontextes zu generieren.
streamlit: Ein Framework zur Erstellung interaktiver Webanwendungen in Python. Es wird sich als nützlich erweisen, um eine Benutzeroberfläche zu erstellen, in die Nutzer ihre Google-Suchanfragen und KI-Eingaben eingeben und die Ergebnisse dynamisch anzeigen können.

Führen Sie in einer aktivierten virtuellen Umgebung den folgenden Befehl aus, um alle Abhängigkeiten zu installieren:

pip install python-dotenv requests langchain-community openai streamlit

Im Einzelnen werden wir AsyncChromiumLoader aus der langchain-community verwenden, der die folgenden Abhängigkeiten benötigt:

pip install --upgrade --quiet playwright beautifulsoup4 html2text

Damit Playwright richtig funktioniert, müssen Sie auch die Browser mit installieren:

playwright install

Die Installation all dieser Bibliotheken wird eine Weile dauern, haben Sie also etwas Geduld.

Großartig! Sie sind bereit, Ihre Python-Logik zu schreiben.

Schritt #3: Bereiten Sie Ihr Projekt vor

Fügen Sie in app.py die folgenden Importe hinzu:

from dotenv import load_dotenv

importieren os

importiere Anfragen

from langchain_community.document_loaders import AsyncChromiumLoader

from langchain_community.document_transformers import BeautifulSoupTransformer

von openai importieren OpenAI

importiere streamlit als st

Erstellen Sie dann eine .env-Datei in Ihrem Projektordner, um alle Ihre Anmeldedaten zu speichern. Ihre Projektstruktur wird nun wie unten dargestellt aussehen:

Verwenden Sie die folgende Funktion in app.py, um python-dotenv anzuweisen, die Umgebungsvariablen aus .env zu laden:

load_dotenv()

Sie können nun Umgebungsvariablen aus .env oder dem System mit importieren:

os.environ.get("<ENV_NAME>")

Dies ist auch der Grund, warum wir die os Python Standardbibliothek importiert haben.

Schritt #4: SERP-API konfigurieren

Wie in der Einleitung erwähnt, werden wir uns auf die SERP-API von Bright Data stützen, um Inhalte von Suchmaschinenergebnisseiten abzurufen und diese in unserem Python-RAG-Workflow zu verwenden. Konkret werden wir Text aus den URLs der Webseiten extrahieren, die von der SERP-API zurückgegeben werden.

Um SERP-API einzurichten, lesen Sie die offizielle Dokumentation. Alternativ können Sie auch die unten stehenden Anweisungen befolgen.

Wenn Sie noch kein Konto erstellt haben, melden Sie sich bei Bright Data an. Navigieren Sie nach der Anmeldung zum Dashboard Ihres Kontos:

Klicken Sie dort auf die Schaltfläche “Get proxy products”.

Dadurch gelangen Sie auf die folgende Seite, auf der Sie auf die Zeile “SERP-API” klicken müssen:

Schalten Sie auf der SERP-API-Produktseite den Schalter “Zone aktivieren” um, um das Produkt zu aktivieren:

Kopieren Sie nun den SERP-API-Host, den Port, den Benutzernamen und das Kennwort in den Abschnitt “Zugriffsparameter” und fügen Sie sie Ihrer .env-Datei hinzu:

BRIGHT_DATA_SERP_API_HOST="<IHR_HOST>"

BRIGHT_DATA_SERP_API_PORT=<IHR_PORT>

BRIGHT_DATA_SERP_API_USERNAME="<IHR_BENUTZERNAME>"

BRIGHT_DATA_SERP_API_PASSWORD="<IHR_PASSWORD>"

Ersetzen Sie die <YOUR_XXXX>-Platzhalter durch die von Bright Data auf der SERP-API-Seite angegebenen Werte.

Beachten Sie, dass der Host in “Zugriffsparameter” ein Format wie folgt hat:

brd.superproxy.io:33335

Sie müssen ihn wie folgt aufteilen:

BRIGHT_DATA_SERP_API_HOST="brd.superproxy.io"

BRIGHT_DATA_SERP_API_PORT=33335

Großartig! Jetzt können Sie SERP-API in Python verwenden.

Schritt #5: Implementieren Sie die SERP Scraping Logik

Fügen Sie in app.py die folgende Funktion ein, um die erste number_of_urls URLs von einer Google SERP-Seite abzurufen:

def get_google_serp_urls(query, number_of_urls=5):

# führt eine SERP-API-Anfrage von Bright Data aus

# mit JSON-Autoparsing

host = os.environ.get("BRIGHT_DATA_SERP_API_HOST")

Anschluss = os.environ.get("BRIGHT_DATA_SERP_API_PORT")

benutzername = os.environ.get("BRIGHT_DATA_SERP_API_USERNAME")

Kennwort = os.environ.get("BRIGHT_DATA_SERP_API_PASSWORD")

proxy_url = f "http://{Benutzername}:{Passwort}@{host}:{port}"

proxies = {"http": proxy_url, "https": proxy_url}

url = f "https://www.google.com/search?q={query}&brd_json=1"

response = requests.get(url, proxies=proxies, verify=False)

# Abrufen der geparsten JSON-Antwort

response_data = response.json()

# Extrahiert eine "number_of_urls"-Anzahl von

# Google SERP URLs aus der Antwort

google_serp_urls = []

if "organic" in response_data:

for item in response_data["organic"]:

if "link" in item:

google_serp_urls.append(item["link"])

return google_serp_urls[:number_of_urls]

Hiermit wird eine HTTP-GET-Anfrage an die SERP-API mit der im Argument query angegebenen Suchanfrage gestellt. Der Query-Parameter brd_json=1 sorgt dafür, dass SERP-API die Ergebnisse in JSON parst, und zwar im folgenden Format:

{

"general": {

"search_engine": "google",

"results_cnt": 1980000000,

"search_time": 0.57,

"Sprache": "en",

"mobil": falsch,

"basic_view": false,

"search_type": "text",

"page_title": "pizza - Google Suche",

"code_version": "1.90",

"timestamp": "2023-06-30T08:58:41.786Z"

},

"input": {

"original_url": "https://www.google.com/search?q=pizza&brd_json=1",

"user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12) AppleWebKit/608.2.11 (KHTML, wie Gecko) Version/13.0.3 Safari/608.2.11",

"request_id": "hl_1a1be908_i00lwqqxt1"

},

"organic": [

{

"link": "https://www.pizzahut.com/",

"display_link": "https://www.pizzahut.com",

"title": "Pizza Hut | Delivery & Carryout - No One OutPizzas The Hut!",

"image": "der Kürze halber weggelassen...",

"image_alt": "pizza von www.pizzahut.com",

"image_base64": "der Kürze halber weggelassen...",

"rank": 1,

"global_rank": 1

},

{

"link": "https://www.dominos.com/en/",

"display_link": "https://www.dominos.com ' ...",

"title": "Domino's: Pizza Delivery & Carryout, Pasta, Chicken & More",

"description": "Bestellen Sie Pizza, Pasta, Sandwiches & mehr online zum Mitnehmen oder Liefern bei Domino's. Speisekarte ansehen, Standorte finden, Bestellungen verfolgen. Sign up for Domino's email ...",

"image": "der Kürze halber weggelassen...",

"image_alt": "pizza von www.dominos.com",

"image_base64": "der Kürze halber weggelassen...",

"rank": 2,

"global_rank": 3

},

// der Kürze halber weggelassen...

],

// der Kürze halber weggelassen...

}

Die letzten Zeilen der Funktion rufen jede SERP-URL aus den resultierenden JSON-Daten ab, wählen nur die ersten number_of_urls-URLs aus und geben sie in einer Liste zurück.

Nun ist es an der Zeit, Text aus diesen URLs zu extrahieren!

Schritt #6: Extrahieren von Text aus den SERP-URLs

Definieren Sie eine Funktion, die Text aus jeder der SERP-URLs extrahiert:

def extract_text_from_urls(urls, number_of_words=600):

# Weisen Sie eine Headless-Chrome-Instanz an, die angegebenen URLs zu besuchen.

# mit dem angegebenen User-Agent

loader = AsyncChromiumLoader(

urls,

user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/129.0.0.0 Safari/537.36",

)

html_documents = loader.load()

# Verarbeitung der extrahierten HTML-Dokumente, um Text daraus zu extrahieren

bs_transformer = BeautifulSoupTransformer()

docs_transformed = bs_transformer.transform_documents(

html_documents,

tags_to_extract=["p", "em", "li", "strong", "h1", "h2"],

unwanted_tags=["a"],

remove_comments=True,

)

# sicherstellen, dass jedes HTML-Textdokument nur eine Zahl enthält

# Anzahl_der_Wörter Wörter

extrahierte_text_liste = []

for doc_transformed in docs_transformed:

# den Text in Wörter aufteilen und die erste Anzahl_der_Wörter zusammenfügen

words = doc_transformed.page_content.split()[:number_of_words]

extrahierter_text = " ".join(words)

# Leere Textdokumente ignorieren

if len(extrahierter_text) != 0:

extracted_text_list.append(extracted_text)

return extrahierter_Text_liste

Diese Funktion:

Lädt Webseiten von den als Argument übergebenen URLs mit einer Headless-Chrome-Browser-Instanz.
Verwendet BeautifulSoupTransformer, um den HTML-Code jeder Seite zu verarbeiten und Text aus bestimmten Tags (wie <p>, <h1>, <strong> usw.) zu extrahieren, wobei unerwünschte Tags (wie <a>) und Kommentare ausgelassen werden.
Begrenzt den extrahierten Text für jede Webseite auf eine Anzahl von Wörtern, die durch das Argument number_of_words angegeben wird.
Gibt eine Liste des extrahierten Textes von jeder URL zurück.

Beachten Sie, dass die Tags [“p”, “em”, “li”, “strong”, “h1”, “h2”] ausreichen, um Text aus den meisten Webseiten zu extrahieren. In bestimmten Fällen kann es jedoch erforderlich sein, diese Liste von HTML-Tags anzupassen. Möglicherweise müssen Sie auch die Zielanzahl der Wörter für jedes Textelement erhöhen oder verringern.

Betrachten Sie zum Beispiel die unten stehende Webseite:

Die Anwendung dieser Funktion auf diese Seite führt zu diesem Text-Array:

["Lisa Johnson Mandells Transformers One-Review enthüllt das bisher Unvorstellbare: Es ist einer der besten Animationsfilme des Jahres! Ich hätte nie gedacht, dass ich das mal über einen Transformers-Film schreiben würde, aber Transformers One ist tatsächlich ein außergewöhnlicher Film! ..."]

Unglaublich! Auch wenn er nicht perfekt ist, so ist er doch für KI-Modelle von hoher Qualität.

Die Liste der Textelemente, die von extract_text_from_urls() zurückgegeben wird, stellt den RAG-Kontext dar, der an das OpenAI-Modell weitergegeben wird.

Schritt #7: Erzeugen des RAG Prompts

Definieren Sie eine Funktion, die die KI-Prompt-Anfrage und den Textkontext in den endgültigen RAG-Prompt umwandelt:

def get_openai_prompt(request, text_context=[]):

# Standard-Prompt

prompt = Anfrage

# den Kontext zum Prompt hinzufügen, falls vorhanden

if len(text_context) != 0:

context_string = "nn--------nn".join(text_context)

prompt = f "Beantworten Sie die Anfrage nur mit dem unten stehenden Kontext.nnKontext:n{Kontext_string}nnAnfrage: {Anfrage}"

return prompt

Prompts, die von der vorherigen Funktion zurückgegeben werden, wenn ein RAG-Kontext angegeben ist, haben dieses Format:

Beantworte die Anfrage nur mit dem unten angegebenen Kontext.

Kontext:

Bla bla bla...

--------

Bla bla bla...

--------

Bla bla bla...

Anfrage: <YOUR_REQUEST>

Schritt #8: Ausführen der GPT-Anfrage

Initialisieren Sie zunächst den OpenAI-Client am Anfang der app.py-Datei:

openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

Dies beruht auf der Umgebungsvariablen OPENAI_API_KEY, die Sie direkt in den Umgebungen Ihres Systems oder in der .env-Datei definieren können:

OPENAI_API_KEY="<IHR_API_KEY>"

Ersetzen Sie <YOUR_API_KEY> durch den Wert Ihres OpenAI API-Schlüssels. Wenn Sie nicht wissen, wie Sie ihn bekommen, folgen Sie der offiziellen Anleitung.

Als nächstes schreiben Sie eine Funktion, die den offiziellen OpenAI-Client verwendet, um eine Anfrage an das GPT-4o Mini-KI-Modell zu stellen:

def interrogate_openai(prompt, max_tokens=800):

# Abfrage des OpenAI-Modells mit dem angegebenen Prompt

response = openai_client.chat.completions.create(

model="gpt-4o-mini",

messages=[{"role": "user", "content": prompt}],

max_tokens=max_tokens,

)

return response.choices[0].message.content

Beachten Sie, dass Sie jedes andere von der OpenAI API unterstützte GPT-Modell konfigurieren können.

Wenn Sie die Funktion mit einem Prompt aufrufen, der von get_openai_prompt() zurückgegeben wird und einen bestimmten Textkontext enthält, wird interrogate_openai() die Generierung mit Abfrageerweiterung wie vorgesehen erfolgreich durchführen.

Schritt #9: Erstellen der Anwendungs-UI

Verwenden Sie Streamlit, um ein einfaches Formular UI zu definieren, in dem die Benutzer angeben können:

Die Google-Suchanfrage, die an die SERP-API übergeben werden soll
Die KI-Eingabeaufforderung, die an GPT-4o mini gesendet werden soll

Erreichen Sie dies mit diesen Codezeilen:

with st.form("prompt_form"):

# initialisiere die Ausgabeergebnisse

result = ""

final_prompt = ""

# Textarea für die Eingabe der Google-Suchanfrage durch den Nutzer

google_search_query = st.text_area("Google Search:", None)

# Textfeld für die Eingabe der KI-Eingabeaufforderung durch den Benutzer

anfrage = st.text_area("KI Eingabeaufforderung:", Keine)

# Schaltfläche zum Absenden des Formulars

submitted = st.form_submit_button("Senden")

# wenn das Formular abgeschickt wurde

if submitted:

# Abrufen der Google SERP-URLs aus der angegebenen Suchanfrage

google_serp_urls = get_google_serp_urls(google_search_query)

# extrahiert den Text aus den jeweiligen HTML-Seiten

extracted_text_list = extract_text_from_urls(google_serp_urls)

# Generierung der KI-Eingabeaufforderung unter Verwendung des extrahierten Textes als Kontext

final_prompt = get_openai_prompt(request, extracted_text_list)

# Abfrage eines OpenAI-Modells mit dem generierten Prompt

result = interrogate_openai(final_prompt)

# Dropdown mit dem generierten Prompt

final_prompt_expander = st.expander("KI Final Prompt:")

final_prompt_expander.write(final_prompt)

# Schreiben des Ergebnisses aus dem OpenAI-Modell

st.write(result)

Jetzt geht’s los! Das Python-RAG-Skript ist fertig.

Schritt #10: Alles zusammenfügen

Ihre app.py-Datei sollte den folgenden Code enthalten:

from dotenv import load_dotenv

importieren os

importiere Anfragen

from langchain_community.document_loaders import AsyncChromiumLoader

from langchain_community.document_transformers import BeautifulSoupTransformer

von openai importieren OpenAI

import streamlit as st

# lädt die Umgebungsvariablen aus der .env-Datei

load_dotenv()

# Initialisiere den OpenAI API Client mit deinem API Schlüssel

openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def get_google_serp_urls(query, number_of_urls=5):

# führt eine SERP-API-Anfrage von Bright Data aus

# mit JSON-Autoparsing

host = os.environ.get("BRIGHT_DATA_SERP_API_HOST")

Anschluss = os.environ.get("BRIGHT_DATA_SERP_API_PORT")

benutzername = os.environ.get("BRIGHT_DATA_SERP_API_USERNAME")

Kennwort = os.environ.get("BRIGHT_DATA_SERP_API_PASSWORD")

proxy_url = f "http://{Benutzername}:{Passwort}@{host}:{port}"

proxies = {"http": proxy_url, "https": proxy_url}

url = f "https://www.google.com/search?q={query}&brd_json=1"

response = requests.get(url, proxies=proxies, verify=False)

# Abrufen der geparsten JSON-Antwort

response_data = response.json()

# Extrahiert eine "number_of_urls"-Anzahl von

# Google SERP URLs aus der Antwort

google_serp_urls = []

if "organic" in response_data:

for item in response_data["organic"]:

if "link" in item:

google_serp_urls.append(item["link"])

return google_serp_urls[:anzahl_der_urls]

def extract_text_from_urls(urls, number_of_words=600):

# eine Headless-Chrome-Instanz anweisen, die angegebenen URLs zu besuchen

# mit dem angegebenen User-Agent

loader = AsyncChromiumLoader(

urls,

user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/129.0.0.0 Safari/537.36",

)

html_documents = loader.load()

# Verarbeitung der extrahierten HTML-Dokumente, um Text daraus zu extrahieren

bs_transformer = BeautifulSoupTransformer()

docs_transformed = bs_transformer.transform_documents(

html_documents,

tags_to_extract=["p", "em", "li", "strong", "h1", "h2"],

unwanted_tags=["a"],

remove_comments=True,

)

# sicherstellen, dass jedes HTML-Textdokument nur eine Zahl enthält

# Anzahl_der_Wörter Wörter

extrahierte_text_liste = []

for doc_transformed in docs_transformed:

# den Text in Wörter aufteilen und die erste Anzahl_der_Wörter zusammenfügen

words = doc_transformed.page_content.split()[:number_of_words]

extrahierter_text = " ".join(words)

# Leere Textdokumente ignorieren

if len(extrahierter_text) != 0:

extracted_text_list.append(extracted_text)

return extracted_text_list

def get_openai_prompt(request, text_context=[]):

# Standard-Prompt

prompt = Anfrage

# den Kontext zum Prompt hinzufügen, falls vorhanden

if len(text_context) != 0:

context_string = "nn--------nn".join(text_context)

prompt = f "Beantworten Sie die Anfrage nur mit dem unten stehenden Kontext.nnKontext:n{Kontext_string}nnAnfrage: {Anfrage}"

return prompt

def interrogate_openai(prompt, max_tokens=800):

# Abfrage des OpenAI-Modells mit dem angegebenen Prompt

response = openai_client.chat.completions.create(

model="gpt-4o-mini",

messages=[{"role": "user", "content": prompt}],

max_tokens=max_tokens,

)

return response.choices[0].message.content

# ein Formular in der Streamlit-Anwendung für Benutzereingaben erstellen

mit st.form("prompt_form"):

# initialisiere die Ausgabeergebnisse

result = ""

final_prompt = ""

# Textarea für die Eingabe der Google-Suchanfrage durch den Nutzer

google_search_query = st.text_area("Google Search:", None)

# Textfeld für die Eingabe der KI-Eingabeaufforderung durch den Benutzer

anfrage = st.text_area("KI Eingabeaufforderung:", Keine)

# Schaltfläche zum Absenden des Formulars

submitted = st.form_submit_button("Senden")

# wenn das Formular abgeschickt wurde

if submitted:

# Abrufen der Google SERP-URLs aus der angegebenen Suchanfrage

google_serp_urls = get_google_serp_urls(google_search_query)

# extrahiert den Text aus den jeweiligen HTML-Seiten

extracted_text_list = extract_text_from_urls(google_serp_urls)

# Generierung der KI-Eingabeaufforderung unter Verwendung des extrahierten Textes als Kontext

final_prompt = get_openai_prompt(request, extracted_text_list)

# Abfrage eines OpenAI-Modells mit dem generierten Prompt

result = interrogate_openai(final_prompt)

# Dropdown mit dem generierten Prompt

final_prompt_expander = st.expander("KI Final Prompt")

final_prompt_expander.write(final_prompt)

# Schreiben Sie das Ergebnis aus dem OpenAI-Modell.

st.write(result)

Können Sie es glauben? In weniger als 150 Codezeilen können Sie RAG mit Python realisieren!

Schritt #11: Testen Sie die Anwendung

Starten Sie Ihre Python-RAG-Anwendung mit:

streamlit run app.py

Im Terminal sollten Sie die folgende Ausgabe sehen:

Sie können nun Ihre Streamlit-Anwendung in Ihrem Browser betrachten.

Lokale URL: http://localhost:8501

Netzwerk-URL: http://172.27.134.248:8501

Folgen Sie den Anweisungen und besuchen Sie http://localhost:8501 im Browser. Unten sehen Sie, was Sie sehen sollten:

Wie Sie feststellen können, enthält das Formular die im Code definierten Textbereichseingaben “Google-Suche:” und “KI-Eingabeaufforderung:” sowie die Schaltfläche “Senden” und das Dropdown-Menü “KI-Abschlussaufforderung”.

Testen Sie die Anwendung mit einer Google-Suchanfrage (siehe unten):

Transformers One Rezension

Und eine KI-Aufforderung wie folgt:

Schreiben Sie eine Rezension für den Film Transformers One

Klicken Sie auf “Senden” und warten Sie, während Ihre Anwendung die Anfrage verarbeitet. Nach ein paar Sekunden sollten Sie ein Ergebnis wie dieses erhalten:

Wow! Keine schlechte Kritik…

Wenn Sie die Auswahlliste “KI Final Prompt” erweitern, sehen Sie die vollständige Eingabeaufforderung, die von der Anwendung für RAG verwendet wird.

Et voilà! Sie haben gerade einen Python-RAG-Chatbot mit GPT-4o mini unter Verwendung von SERP-Daten implementiert.

Fazit

In diesem Tutorial haben Sie herausgefunden, was RAG ist und wie es durch die Fütterung von KI-Modellen mit SERP-Daten erreicht werden kann. Insbesondere haben Sie gelernt, einen Python-RAG-Chatbot zu erstellen, der SERP-Daten ausliest und sie in GPT-Modellen verwendet, um die Genauigkeit der Ergebnisse zu verbessern.

Die größte Herausforderung bei diesem Ansatz ist das Scraping von Suchmaschinen wie Google, denn:

Sie ändern häufig die Struktur ihrer SERP-Seiten.
Sie sind durch einige der ausgeklügeltsten Anti-Bot-Maßnahmen geschützt, die es gibt.
Das gleichzeitige Abrufen großer Mengen von SERP-Daten ist komplex und kann viel Geld kosten.

Wie hier gezeigt, können Sie mit der SERP-API von Bright Data ohne großen Aufwand Echtzeit-SERP-Daten von allen wichtigen Suchmaschinen abrufen. Das unterstützt RAG und viele andere Anwendungen. Holen Sie sich jetzt Ihre kostenlose Testversion!

Melden Sie sich jetzt an und finden Sie heraus, welche Proxy-Services oder Scraping-Produkte von Bright Data am besten zu Ihren Anforderungen passen. Starten Sie mit einem Gratis test!

Vertrieb kontaktieren Gratis testen