AI Engineering Academy: 2.6 RAG Beobachtbarkeit - Arize Phoenix Setup

Willkommen zu diesem Notizbuch, in dem wir erforschen werden, wie man Llama Index benutzt, um die Generierung von Retrieval-Erweiterungen einzurichten und zu beobachten (RAG) Rationalisieren.

https://github.com/adithya-s-k/AI-Engineering.academy/tree/main/RAG/01_RAG_Observability

kurz

Dieses Handbuch bietet eine vollständige Anleitung zur Konfiguration der erforderlichen Tools und Bibliotheken, einschließlich eingebetteter Modelle und Vektorspeicherindizes, für eine effiziente Dokumentensuche und Abfrageverarbeitung. Wir behandeln alles von der Installation und Einrichtung bis hin zur Abfrage und zum Abruf relevanter Informationen, um Ihnen zu helfen, die erweiterten Suchfunktionen der RAG-Pipeline in den Griff zu bekommen.

Einführung (ein Thema)

Für den Einstieg in dieses Notizbuch benötigen Sie ein grundlegendes Verständnis von Python und eine gewisse Vertrautheit mit Konzepten des maschinellen Lernens. Wenn Sie mit diesen Konzepten nicht vertraut sind, machen Sie sich keine Sorgen - wir werden Sie Schritt für Schritt durch sie führen!

Vorbedingungen

• Python 3.7+
• Jupyter Notebook oder JupyterLab
• Grundlagen von Python und Machine Learning-Konzepten

1. einstellung

1.1 Installation der erforderlichen Softwarepakete

Um mit der Einrichtung von Arize Phoenix zu beginnen, müssen Sie die erforderlichen Softwarepakete installieren.

Arize Phoenix ist ein umfassendes Tool für die Beobachtbarkeit und Überwachung von maschinellem Lernen und KI-Systemen. Es bietet die Möglichkeit, alle Aspekte von Machine-Learning-Modellen und Datenpipelines zu verfolgen und zu analysieren.

!pip install arize-phoenix
!pip install openinference-instrumentation-openai

Diese Befehle werden installiert:

• arize-phoenixTools für die Beobachtbarkeit von Arbeitsabläufen beim maschinellen Lernen.
• openinference-instrumentation-openaiPakete für die Integration von OpenAI-Modellen mit Beobachtungstools wie Arize Phoenix.

1.2 Einrichten der Arize Phoenix

Es gibt drei Möglichkeiten, die Einstellungen wie folgt vorzunehmen:

Mehr lesen Hier.

• Befehlszeile (Informatik)

  python3 -m phoenix.server.main serve
  

• Docker startet das Docker-Image von phoenix mit dem folgenden Befehl:

  docker run -p 6006:6006 -p 4317:4317 arizephoenix/phoenix:latest
  

  Dadurch werden die Phoenix-Benutzeroberfläche und die REST-API auf localhost:6006 und der gRPC-Endpunkt für Spans auf localhost:4317 bereitgestellt.

• Notizbücher

  phoenix als px importieren
  px.launch_app()
  

1.3 Importieren Sie die erforderlichen Bibliotheken und konfigurieren Sie die Umgebung

Importieren Sie die erforderlichen Bibliotheken und richten Sie die Umgebung ein, bevor Sie mit der Datenverarbeitung und -auswertung fortfahren:

json importieren
importieren os
von getpass importieren getpass
importieren nest_asyncio
importiere pandas als pd
von tqdm importieren tqdm
importiere phoenix als px
# ermöglicht die gleichzeitige Auswertung in einer Laptop-Umgebung
nest_asyncio.apply()
# Setzen von Anzeigeoptionen für Pandas DataFrame, um mehr Inhalt anzuzeigen
pd.set_option("display.max_colwidth", 1000)

• json, osPython: Standard-Python-Bibliothek für den Umgang mit JSON-Daten und die Interaktion mit dem Betriebssystem.
• getpassEin Tool zur sicheren Eingabe von Passwörtern.
• nest_asyncioErmöglicht die Verwendung von asyncio in Jupyter-Notebooks.
• Pandas (pd): Eine leistungsstarke Python-Bibliothek zur Datenmanipulation.
• tqdmFortschrittsanzeige für die Schleife, um den Fortschritt der Datenverarbeitung zu verfolgen.
• phoenix (px): Teil des Arize Observability Tools, das eine interaktive Benutzeroberfläche für die Untersuchung von Daten und die Überwachung von Machine-Learning-Modellen bietet.

konfigurieren. nest_asyncio um gleichzeitige Auswertungen in einer Notebook-Umgebung zu ermöglichen und um die maximale Spaltenbreite des Pandas DataFrame zu setzen, um die Lesbarkeit zu verbessern.

1.4 Starten der Phoenix-Anwendung

px.launch_app()

Diese Funktion initialisiert und startet die Phoenix-Anwendung, die in einer neuen Registerkarte des Standardbrowsers geöffnet wird und eine interaktive Schnittstelle zur Untersuchung von Datensätzen, zur Visualisierung der Modellleistung und zur Fehlersuche bietet.

1.5 Anzeigen von Phoenix-Anwendungssitzungen

Sobald die Phoenix-Anwendung gestartet ist, können Sie mithilfe von Sitzungsobjekten direkt im Notebook mit der Anwendung interagieren. Führen Sie den folgenden Code aus, um die Phoenix-Anwendung zu starten und sie in der aktuellen Sitzung anzuzeigen:

# Starten und Anzeigen einer Phoenix-Anwendungssitzung
(Sitzung := px.launch_app()).view()

Diese Codezeile startet die Phoenix-Anwendung und weist die Sitzung einer Variablen namens Sitzung zu, indem sie die Ansicht() Die Methode zeigt Phoenix-Anwendungen direkt auf der Notebook-Oberfläche an und bietet so ein integriertes Erlebnis, ohne zwischen Browser und Notebook wechseln zu müssen.

1.6 Einstellung des Endpunkts der Aufzeichnung

Um Trace-Daten an eine Phoenix-Anwendung zur Analyse und Beobachtung zu senden, definieren Sie die Endpunkt-URL, an der die Phoenix-Anwendung auf eingehende Daten wartet.

endpoint = "http://127.0.0.1:6006/v1/traces"

Endpunkt Variable zur Speicherung der Endpunkt-URL, die von der Phoenix-Anwendung verwendet wird, um auf eingehende Trace-Daten zu warten.

2. die Verfolgung von OpenAI

Mehr Integration. Lesen.

2.1 OpenAI-Pakete installieren und importieren

!pip install openai
importieren Sie openai

openaiPython-Client-Bibliothek für die OpenAI-API. Sie ermöglicht es Ihnen, Anfragen an die OpenAI-Modelle (einschließlich GPT-3 und GPT-4) für eine Vielzahl von Aufgaben zu senden.

2.2 Konfigurieren des OpenAI-API-Schlüssels

openai importieren
importieren os
from getpass import getpass
# Holen Sie sich den API-Schlüssel aus der Umgebungsvariablen, wenn er nicht gesetzt ist, fragen Sie den Benutzer danach
if not (openai_api_key := os.getenv("OPENAI_API_KEY")):: openai_api_key = getpass("🖩")
openai_api_key = getpass("🔑 Geben Sie Ihren OpenAI-API-Schlüssel ein:")
# Einstellen des API-Schlüssels für einen OpenAI-Client
openai.api_key = openai_api_key
# speichert den API-Schlüssel in einer Umgebungsvariablen zur späteren Verwendung
os.environ["OPENAI_API_KEY"] = openai_api_key

• Abrufen des API-Schlüssels: Der Code versucht zunächst, den API-Schlüssel aus der Umgebungsvariablen (OPENAI_API_KEY) abzurufen. Wenn der Schlüssel nicht gefunden wird, wird der Benutzer zur sicheren Eingabe über getpass aufgefordert.
• API-Schlüssel setzen: Der abgefragte oder gelieferte API-Schlüssel wird dann als Schlüssel für die OpenAI-Client-Bibliothek gesetzt.
• Speichern des API-Schlüssels: Speichern Sie den API-Schlüssel schließlich in einer Umgebungsvariablen, um sicherzustellen, dass er während der Sitzung immer verfügbar ist.

2.3 Einrichten von OpenTelemetry für das Tracking

Um das Tracing für Ihre OpenAI-Interaktionen zu aktivieren, konfigurieren Sie OpenTelemetry und richten Sie die erforderlichen Komponenten ein.

from opentelemetry import trace as trace_api
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
von opentelemetry.sdk importieren trace as trace_sdk
von opentelemetry.sdk.trace.export importieren SimpleSpanProcessor
# Einrichten des Tracer-Providers
tracer_provider = trace_sdk.TracerProvider()
# Definieren des OTLP Span-Exporters mit Endpunkten
span_exporter = OTLPSpanExporter(endpoint)
# Span-Prozessor für die Verarbeitung und den Export von Spans einrichten
span_processor = SimpleSpanProcessor(span_exporter)
# Span-Prozessor zum Tracer-Provider hinzufügen
tracer_provider.add_span_processor(span_processor)
# Einstellen des globalen Tracer-Providers
trace_api.set_tracer_provider(tracer_provider)

OpenTelemetry-Bibliothek

Im mitgelieferten Code werden mehrere OpenTelemetry-Bibliotheken verwendet, um die Verfolgung einzurichten. Im Folgenden finden Sie eine Übersicht über die einzelnen Bibliotheken:

• offene Telemetrie:entspricht Englisch -ity, -ism, -izationOpenTelemetry: Die Kernbibliothek von OpenTelemetry, die APIs für Tracking und Metriken bereitstellt.VerwendungTrace-Modul: Enthält das Trace-Modul zur Erstellung und Verwaltung von Traces.
• opentelemetry.exporter.otlp.proto.http.trace_exporter:entspricht Englisch -ity, -ism, -izationBietet einen Trace-Exporter mit OTLP (OpenTelemetry Protocol) über HTTP.Verwendung: Das Modul OTLPSpanExporter Klasse wird verwendet, um Tracking-Daten an ein OTLP-kompatibles Backend zu senden, und wird durch die Einrichtung von Endpunkten konfiguriert.
• opentelemetry.sdk.trace:entspricht Englisch -ity, -ism, -izationSDK: Enthält SDK-Implementierungen für die Nachverfolgung, einschließlich TracerProvider.Verwendung::
  • TracerProviderTracer: Verwaltet Tracer-Instanzen und ist verantwortlich für den Export von Spans (Arbeitseinheiten), die in Traces gesammelt werden.
  • SimpleSpanProcessorEin Prozessor, der Exportspannen synchronisiert, um Daten zu verarbeiten und an den Exporteur zu senden.
• opentelemetry.sdk.trace.export:entspricht Englisch -ity, -ism, -izationKlassen für den Export von Tracking-Daten.Verwendung::
  • SimpleSpanProcessorSpans: Die Verarbeitung von Spans und deren Export mit dem angegebenen Exporter stellt sicher, dass die Daten zur Analyse an das Backend gesendet werden.

2.4 Instrumentierung von OpenAI mit OpenInference

Um OpenTelemetry in OpenAI zu integrieren und Tracking für OpenAI-Modellinteraktionen zu ermöglichen, verwenden Sie das Tracking aus dem openinference Bibliotheken OpenAIInstrumentor.

from openinference.instrumentation.openai import OpenAIInstrumentor
# instanziiert und wendet die Instrumentierung auf OpenAI an
OpenAIInstrumentor().instrument()

• OpenAIInstrumentor: Von openinference Bibliotheksklassen für die Instrumentierung von OpenAIs API-Aufrufen, um Tracking und Beobachtbarkeit zu ermöglichen.
• instrument()Diese Methode konfiguriert den OpenAI-API-Client, um automatisch Trace-Daten zu erzeugen und an das OpenTelemetry-Backend zu senden. Sie integriert die konfigurierten Trace-Einstellungen und ermöglicht es Ihnen, den Prozess der Interaktion mit OpenAI-Modellen zu überwachen und zu analysieren.

Durch die Ausführung dieses Codes können Sie sicherstellen, dass alle OpenAI-API-Aufrufe nachverfolgt werden, um detaillierte Einblicke in die Modellnutzung und -leistung zu erhalten.

2.5 Eine Anfrage an die OpenAI-API stellen

Um mit OpenAIs API zu interagieren und eine Antwort zu erhalten, verwenden Sie den folgenden Code. Dieses Beispiel zeigt, wie man eine Anfrage zur Chatvervollständigung erstellt und die Ergebnisse über die OpenAI-API ausgibt:

OpenAI importieren
# Erstellen Sie eine Instanz des OpenAI-Clients
client = openai.OpenAI()
# stellt eine Anfrage zum Abschluss eines Chats an die OpenAI-API
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Schreib ein Haiku."}],
)
# Drucken Sie den Inhalt der Antwort
print(antwort.auswahlen[0].nachricht.inhalt)

• openai.OpenAI()Initialisieren einer OpenAI-Client-Instanz, die für die Interaktion mit der OpenAI-API verwendet werden kann.
• client.chat.completions.create()Senden Sie eine Anfrage an die OpenAI-API, um ein Chat-Komplement zu erstellen.
  • model="gpt-4o"Geben Sie den Namen des Modells an, das für die Erstellung des Komplements verwendet wird. Vergewissern Sie sich, dass der Modellname korrekt ist und dass Sie ihn in Ihrem OpenAI-API-Konto aktiviert haben.
  • Nachrichten:: Eine Liste von Nachrichten, die den Dialogverlauf enthält. Dieses Beispiel enthält eine einzige Nachrichtenanfrage des Benutzers: "Schreibe ein Haiku."
• response.choices[0].message.contentExtrahiert und druckt modellgenerierte Ergänzungen.

3. den Llama-Index verfolgen

3.1 Installieren und Importieren der erforderlichen Bibliotheken

!pip install llama-index
!pip install llama-index-core
!pip install llama-index-llms-openai
!pip install openinference-instrumentation-llama-index==2.2.4
!pip install -U llama-index-rückrufe-arize-phoenix
!pip install "arize-phoenix[llama-index]"

• Lama-Index:: Kernpaket für Llama-Index-Funktionalität.
• lama-index-coreLlama Index: Bietet die Kernfunktionen und Werkzeuge von Llama Index.
• llama-index-llms-openaiLlama Index: Ein Paket zur Integration von Llama Index mit OpenAI-Modellen.
• openinference-instrumentation-llama-index==2.2.4Llama Index: Stellt Werkzeuge für die Instrumentierung von Llama-Index-Interaktionen bereit.
• llama-index-callbacks-arize-phoenixBietet Integration mit Arize Phoenix Rückrufe.
• arize-phoenix [llama-index]Erweiterung von Arize Phoenix zur Unterstützung von Llama Index Tracking.

3.2 Abrufen der URL der aktiven Phoenix-Sitzung

# Abrufen der URL der derzeit aktiven Phoenix-Sitzung
px.active_session().url

Greifen Sie auf die derzeit aktive Phoenix-Sitzung zu und rufen Sie deren URL ab, um die Phoenix-Schnittstelle zur Überwachung und Analyse von Tracking-Daten anzuzeigen oder freizugeben.

3.3 Einrichten der Llama-Index-Verfolgung

Um OpenTelemetry-Tracking für Llama Index einzurichten, konfigurieren Sie den Tracer-Anbieter und integrieren Sie Llama Index Instrumentor.

from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk importiere trace as trace_sdk
von opentelemetry.sdk.trace.export importieren SimpleSpanProcessor
# Einrichten des Tracer-Providers
tracer_provider = trace_sdk.TracerProvider()
# Span-Prozessor zum Tracer-Provider hinzufügen
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))
# Instrumentierung von Llama Index unter Verwendung des Tracer Providers
LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)

• LlamaIndexInstrumentor: Von openinference.instrumentation.llama_index Klasse für die Verfolgung und Beobachtung von Instrumenten des Llama-Index.
• trace_sdk.TracerProvider()Initialisieren eines neuen Tracer-Providers zur Erstellung und Verwaltung von Trace-Daten.
• SimpleSpanProcessorSynchronisierung des Exports von Spans und Übermittlung der Daten an das Backend.
• LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)Llama Index: Wenden Sie die Instrumentierung auf den Llama-Index an und verwenden Sie den mitgelieferten Tracer-Anbieter für das Tracing.

3.4 Verwendung von OpenAI zur Interaktion mit dem Llama-Index

Um eine Abschlussanfrage über Llama Index unter Verwendung eines OpenAI-Modells durchzuführen, verwenden Sie den folgenden Code:

from llama_index.llms.openai import OpenAI
# Initialisieren Sie das OpenAI-Modell
llm = OpenAI(model="gpt-4o-mini")
# initiiert eine Abschlussanforderung
resp = llm.complete("Paul Graham ist ")
# Druckt die Antwort
print(resp)

• from llama_index.llms.openai import OpenAI: Von lama_index Paket, um OpenAI-Klassen für die Interaktion mit OpenAI-Modellen zu importieren.
• OpenAI(model="gpt-4o-mini")Initialisieren der OpenAI-Klasseninstanz mit dem angegebenen Modell (z.B. gpt-4).
• llm.complete(...)Sendet Aufforderungstext an das Modell, um Antwortinhalte zu erzeugen.

3.5 Chat-Interaktion mit Llama Index unter Verwendung von OpenAI

from llama_index.llms.openai importieren OpenAI
von llama_index.core.llms importieren ChatMessage
# Initialisieren Sie das OpenAI-Modell
llm = OpenAI()
# Definieren Sie ChatMessage
messages = [
ChatMessage(
role="system", content="Du bist ein Pirat mit einer bunten Persönlichkeit"
),
ChatMessage(role="user", content="Wie ist dein Name"), ]
]
# Abrufen der Ergebnisse der Antwort des Modells
resp = llm.chat(messages)

• OpenAIKlassen, die zur Interaktion mit OpenAI-Modellen verwendet werden.
• ChatMessageKlasse zur Formatierung von Chat-Nachrichten.
• OpenAI()Initialisieren einer Instanz der OpenAI-Klasse.
• ChatMessageErzeugt ein Chat-Nachrichten-Objekt mit Angabe der Rolle (z. B. "System", "Benutzer") und des Inhalts der Nachricht.
  • role="system"Definition von Systemmeldungen, um den Kontext oder die Persönlichkeit des Modells festzulegen.
  • role="Benutzer"Repräsentiert eine vom Benutzer gesendete Nachricht.
• llm.chat(nachrichten)Sendet die definierte Nachricht an das Modell und empfängt das Ergebnis der Antwort.

Dieser Code interagiert mit dem OpenAI-Modell durch System- und Benutzernachrichteneinstellungen für den Chat.

4. die Beobachtung des RAG-Prozesses

4.1 Einrichten der Umgebung für die Beobachtung des RAG-Prozesses

!pip install llama-index
!pip install llama-index-vektor-speicher-qdrant
!pip install llama-index-leser-datei
!pip install llama-index-einbettungen-schnell-einbetten
!pip install llama-index-llms-openai
!pip install -U qdrant_client fastembed

• Lama-IndexLlama Index: Kernpaket für Llama Index Funktionalität.
• llama-index-vector-stores-qdrantQdrant: Integration von Qdrant als Vektorspeicher für Llama Index.
• lama-index-leser-dateiLlama Index: Ermöglicht das Lesen von Dateien für Llama Index.
• llama-index-embeddings-fastembedFastEmbed: Unterstützung für Llama Index zur Erzeugung von Vektoreinbettungen.
• llama-index-llms-openaiLlama Index: Integration von OpenAI-Modellen in Llama Index.
• qdrant_ClientQdrant: Client-seitige Bibliothek für die Interaktion mit Qdrant, einer Vektorsuchmaschine.
• fastembedLibrary for fast generation of embedding vectors: Bibliothek zur schnellen Erzeugung von Einbettungsvektoren.

4.2 Vorbereitung eines RAG-Prozesses mit Einbettung und Dokumentenindizierung

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.embeddings.fastembed importieren FastEmbedEmbedding
# from llama_index.embeddings.openai importieren OpenAIEmbedding
from llama_index.core.settings importieren Einstellungen
Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-de-v1.5")
# Settings.embed_model = OpenAIEmbedding(embed_batch_size=10)
Dokumente = SimpleDirectoryReader("Daten").load_data()
index = VectorStoreIndex.from_documents(documents)

• VectorStoreIndexVektorspeicher: Klassen zur Erstellung und Verwaltung von Vektorspeicherindizes. Der Index führt eine effiziente Ähnlichkeitssuche und -abfrage auf der Grundlage von Dokumentvektoren durch.
• SimpleDirectoryReaderKlasse, die Dokumente aus einem bestimmten Verzeichnis liest und die geladenen Dateien für die Indizierung vorverarbeitet.
• FastEmbedEmbeddingEinbettungsmodell: Klasse zur Erzeugung von Texteinbettungsvektoren unter Verwendung der FastEmbed-Bibliothek. Geben Sie den Modellnamen als "BAAI/bge-base-en-v1.5".
• from llama_index.embeddings.openai import OpenAIEmbedding::
  • OpenAIEmbeddingEinbettungsmodell: Die Einbettungsmodellklasse, die zur Erzeugung von Vektoren über den OpenAI-Einbettungsdienst verwendet wird. Sie ist standardmäßig auskommentiert. Wenn Sie ein OpenAI-Modell anstelle von FastEmbed verwenden möchten, können Sie es auskommentieren und die Parameter konfigurieren, z. B. embed_batch_size.
• EinstellungenKlasse zur Einstellung der globalen Einbettungsmodellkonfiguration. Die Konfiguration des globalen Einbettungsmodells kann durch die Angabe der einbetten_model Attributzuweisung, die das zu verwendende Einbettungsmodell angibt.
• Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-de-v1.5")Einstellung der globalen Nutzung FastEmbedEmbedding als ein Einbettungsvektormodell.
• Dokumente = SimpleDirectoryReader("Daten").load_data(): Aus dem Katalog "Daten" Laden und Vorverarbeiten von Dokumentendaten. Stellen Sie sicher, dass die Verzeichnisnamen an den tatsächlichen Pfad des Projekts angepasst sind.
• index = VectorStoreIndex.from_documents(documents)Erstellen eines Vektor-Speicher-Index auf der Grundlage vorverarbeiteter Dokumente. Dieser Schritt implementiert eine vektorisierte Darstellung des Dokuments und ermöglicht vektorbasierte Abfragen.

4.3 Abfrage-Vektor-Speicherindex

Sobald der Index des Vektorspeichers eingerichtet ist, können Sie ihn verwenden, um Abfragen durchzuführen und relevante Informationen abzurufen.

query_engine = index.as_query_engine()
response = query_engine.query("Was hat der Autor gemacht, als er aufwuchs?")
response = query_engine.query("Was hat der Autor gemacht, als er aufwuchs?") print(response)

• as_query_engine():: Wille VectorStoreIndex Konvertieren in eine Abfrage-Engine. Mit dieser Engine können Sie auf der Grundlage einer Vektordarstellung der in einem Index gespeicherten Dokumente Suchen durchführen und Informationen abrufen.
• Abfrage()Ausführen einer Abfrage in einem Vektorspeicherindex. Die Abfragezeichenfolge "Was hat der Autor gemacht, als er aufwuchs?" wird verwendet, um nach relevanten Dokumenten zu suchen und Informationen auf der Grundlage des durch die Vektoreinbettung bereitgestellten Kontexts abzurufen.

Endlich.Antwort Enthält Informationen, die aus Vektorspeicherindizes abgerufen werden, die auf der Grundlage von Abfragen und Indexdokumenten erstellt werden.

ein Urteil fällen

In diesem Leitfaden haben wir einen Retrieval Augmented Generation (RAG)-Prozess mit Llama Index eingerichtet und ihn mit verschiedenen Komponenten integriert, um seine Funktionalität zu beobachten. Zunächst haben wir die erforderlichen Bibliotheken konfiguriert und installiert, darunter Llama Index, OpenTelemetry und verschiedene Einbettungsmodelle.

Als nächstes haben wir Folgendes getan:

• Initialisieren und konfigurieren Sie das Einbettungsmodell, ggf. unter Verwendung von FastEmbed- oder OpenAI-Modellen.
• Lädt und indiziert Dokumente aus dem Katalog, um Daten für die Abfrage vorzubereiten.
• Richten Sie die Abfragemaschine ein, um Suchen durchzuführen und relevante Informationen auf der Grundlage indizierter Dokumente abzurufen.

Wenn Sie diese Schritte befolgt haben, haben Sie erfolgreich einen RAG-Prozess vorbereitet, der ein effizientes Abrufen von Dokumenten und die Verarbeitung von Anfragen ermöglicht. Die Einrichtung bietet fortgeschrittene Such- und Informationsabfragefunktionen unter Verwendung vektorbasierter Einbettung und Indizierung.

Sie können gerne mit verschiedenen Konfigurationen und Abfragen experimentieren, um die Möglichkeiten des RAG-Prozesses weiter zu erforschen. Wenn Sie Fragen haben oder weitere Anpassungen vornehmen möchten, konsultieren Sie bitte die Dokumentation der von Ihnen verwendeten Bibliothek, um weitere Hinweise zu erhalten.

Der Leitfaden für Laien zum Einstieg in die KI

Hilft Ihnen, die Nutzung von KI-Tools kostengünstig und von Null an zu erlernen.KI ist, wie Bürosoftware, eine wesentliche Fähigkeit für jeden. Die Beherrschung von KI verschafft Ihnen einen Vorteil bei der Stellensuche und die Hälfte des Aufwands bei Ihrer zukünftigen Arbeit und Ihrem Studium.

Details ansehen>