3 Fortgeschrittene Strategien für Retriever in Langchain

Abruf von Langchain: Effizienter und flexibler Zugang zu Dokumenten

Der Suchende im Langchain -Framework spielt eine entscheidende Rolle und bietet eine flexible Schnittstelle für die Rückgabe von Dokumenten auf der Grundlage unstrukturierter Abfragen. Im Gegensatz zu Vector -Datenbanken muss der Sucher keine Dokumente speichern. Während Vector -Datenbanken als Grundlage für Retiers dienen können, gibt es verschiedene Arten von Retiers, die jeweils für einen bestimmten Anwendungsfall anpassbar sind.

Lernziele

• Verstehen Sie die Schlüsselrolle von Suchenden in Langchain und erzielen Sie ein effizientes und flexibles Abrufen von Dokumenten, um verschiedene Anwendungsanforderungen zu erfüllen.
• Erfahren Sie, wie Langchains Sucher (von Vector-Datenbanken bis hin zu Multi-Querien und Kontextkomprimierung) den Zugriff auf relevante Informationen vereinfacht.
• Dieser Handbuch deckt verschiedene Suchertypen in Langchain ab und erklärt, wie jeder Sucher angepasst wird, um die Abfrageverarbeitung und den Datenzugriff zu optimieren.
• Geben Sie in Langchains Sucherfunktionen ein und überprüfen Sie Tools zur Verbesserung der Genauigkeit und Relevanz von Dokumenten.
• Erfahren Sie, wie sich Langchains benutzerdefinierte Retriever an bestimmte Bedürfnisse anpasst, sodass Entwickler hochverantwortliche Anwendungen erstellen können.
• Erforschen Sie die Suchtechniken von Langchain, die Sprachmodelle und Vektordatenbanken integrieren, um genauere und effizientere Suchergebnisse zu erhalten.

Inhaltsverzeichnis

• Lernziele
• Sucher in Langchain
• Verwenden Sie die Vektordatenbank als Sucher
• Verwenden von MultiquyRetriever
  • Erstellen Sie eine Beispielvektor -Datenbank
  • Einfache Verwendung
  • Benutzerdefinierte Tipps
• So suchen Sie mithilfe der Kontextkomprimierung
  • Überblick über die Kontextkomprimierung
• Erstellen Sie einen benutzerdefinierten Sucher
  • Schnittstelle
  • Beispiel
• abschließend
• Häufig gestellte Fragen

Sucher in Langchain

Der Suchende empfängt eine String -Abfrage als Eingabe und gibt eine Liste von Dokumentobjekten aus. Dieser Mechanismus ermöglicht es Anwendungen, relevante Informationen effizient zu erwerben und erweiterte Interaktionen mit großen Datensätzen oder Wissensbasis zu ermöglichen.

1. Verwenden Sie die Vektordatenbank als Sucher

Der Vektordatenbank -Retriever ruft Dokumente effizient mithilfe von Vektordarstellungen ab. Es fungiert als leichter Wrapper für Vektorspeicherklassen, entspricht der Sucher -Schnittstelle und verwendet Methoden wie die Suche nach Ähnlichkeiten und maximale Grenzkorrelation (MMR).

Verwenden Sie die Methode .as_retriever , um einen Retriever aus einer Vektor -Datenbank zu erstellen. Beispielsweise können wir für eine Pnecone -Vektor -Datenbank, die auf Kundenbewertungen basiert, sie wie folgt einrichten:

 von Langchain_Community.document_loaders importieren csvloader
von Langchain_Community.VectorStores Pinecone importieren
von Langchain_openai importieren openaiembedings
von Langchain_text_splitters importieren charaktertextsplitter

Loader = csvloader ("Customer_reviews.csv")
documents = lader.load ()
text_splitter = charaktertextsplitter (chunk_size = 500, chunk_overlap = 50)
text = text_splitter.split_documents (Dokumente)
Einbettungen = OpenAiembedings ()
VectorStore = PineCone.From_Documents (Texte, Embeddeds)
retriever = vectorStore.as_retriever ()

Wir können diesen Sucher jetzt verwenden, um verwandte Kommentare abzufragen:

 docs = retriever.invoke ("Was denken Kunden über die Akkulaufzeit?")

Standardmäßig verwendet der Sucher die Ähnlichkeitssuche, aber wir können MMR als Suchtyp angeben:

 retriever = vectorStore.as_retriever (search_type = "mmr"))

Zusätzlich können wir Parameter wie Ähnlichkeitsbewertungsschwellen übergeben oder Top-K verwenden, um die Anzahl der Ergebnisse zu begrenzen:

 retriever = vectorStore.as_retriever (search_kwargs = {"k": 2, "Score_Threshold": 0.6})

Ausgabe:

Die Verwendung einer Vektordatenbank als Sucher kann das Abrufen von Dokumenten verbessern, indem er einen effizienten Zugriff auf relevante Informationen gewährleistet.

2. Verwenden von MultiquyRetriever

MultiquyRetriever verbessert das abgebundene Abruf der Vektordatenbank, indem gemeinsame Einschränkungen wie Änderungen der Abfrage-Formulierungen und suboptimaler Einbettung angesprochen werden. Unter Verwendung von LLM -Eingabeaufforderungen für das Großsprachmodell (LLM) können für eine bestimmte Benutzereingabe aus verschiedenen Blickwinkeln mehrere Abfragen generiert werden. Dieser Prozess ermöglicht das Abrufen relevanter Dokumente für jede Abfrage und kombiniert die Ergebnisse, um eine Reihe potenzieller Dokumente zu erstellen.

Erstellen Sie eine Beispielvektor -Datenbank

Um MultiquyRetriever zu demonstrieren, erstellen wir einen Vektorspeicher mit der Produktbeschreibung aus der CSV -Datei:

 von Langchain_Community.document_loaders importieren csvloader
von Langchain_Community.VectorStores importieren Sie Faiss
von Langchain_openai importieren openaiembedings
von Langchain_text_splitters importieren charaktertextsplitter

# Produktbeschreibung laden Loader = csvloader ("product_descriptions.csv")
Data = lader.load ()

# Teilen Sie den Text in Blöcke auf text_splitter = charaktertextsplitter (chunk_size = 300, chunk_overlap = 50)
documents = text_splitter.split_documents (Daten)

# Erstellen Sie Vektorspeicher Einbettungen = OpenAiembeddings ()
vectordb = faiss.from_documents (Dokumente, Embeddeds)

Einfache Verwendung

Um MultiquyRetriever zu verwenden, geben Sie die für die Abfragegenerierung verwendete LLM an:

 von langchain.retrievers.multi_query importieren Sie Multiquyrieriever
aus Langchain_openai importieren Sie Chatopenai

FRAGE = "Welche Funktionen schätzen Kunden in Smartphones?"
llm = chatopenai (Temperatur = 0)
retriever_from_llm = multiquyrieriever.from_llm (
    retriever = vectordb.as_retriever (), llm = llm
)
Unique_docs = retriever_from_llm.invoke (Frage)
Len (Unique_docs) # Anzahl der eindeutigen Dokumente abgerufen

Ausgabe:

MultiquyRetriever generiert mehrere Abfragen, wodurch die Vielfalt und Relevanz von abgerufenen Dokumenten verbessert wird.

Benutzerdefinierte Tipps

Um die generierte Abfrage anzupassen, können Sie eine benutzerdefinierte Eingabeaufforderung und einen Ausgangsparser erstellen:

 von Langchain_core.output_parsers importieren BaseOutputParser
von Langchain_core.prompts importieren
Aus dem Einteichen der Einfuhrliste

# Custom Output Parser Class LinelistoutputParser (BaseOutputParser [Liste [STR]]):
    Def Parse (Selbst, Text: STR) -> LISTE [STR]:
        Rückgabeliste (Filter (none, text.strip (). Split ("\ n")))

output_parser = linelistoutputParser ())

# Benutzerdefinierte Eingabeaufforderungen für die Abfragegenerierung query_prompt = fordertemplate (
    input_variables = ["Frage"],
    template = "" "Generieren Sie fünf verschiedene Versionen der Frage: {Frage}" ""
)

llm_chain = query_prompt | llm |

# Initialisieren Sie den Retriever retriever = multiquyrieriever (
    retriever = vectordb.as_retriever (), llm_chain = llm_chain, parser_key = "Linien"
)

Unique_docs = retriever.invoke ("Welche Funktionen schätzen Kunden in Smartphones?")
Len (Unique_docs) # Anzahl der eindeutigen Dokumente abgerufen

Ausgabe

Durch die Verwendung von MultiquyRetriever kann ein effizienterer Suchprozess erzielt werden, um vielfältige und umfassende Ergebnisse basierend auf Benutzerabfragen zu gewährleisten.

3. So suchen Sie mithilfe der Kontextkomprimierung

Das Abrufen relevanter Informationen aus einer großen Sammlung von Dokumenten kann eine Herausforderung sein, insbesondere wenn die Aufnahme von Daten nicht über die spezifische Abfrage bekannt ist, die der Benutzer vornehmen wird. Oft sind wertvolle Erkenntnisse in langwierigen Dokumenten versteckt, was zu ineffizienten und kostspieligen Aufrufen des Sprachmodells (LLM) führt und gleichzeitig weniger Reaktionsfähigkeit als ideal darstellt. Die Kontextkomprimierung löst dieses Problem durch Verbesserung des Suchprozesses und stellt sicher, dass relevante Informationen nur auf der Abfrage des Benutzers zurückgegeben werden. Diese Komprimierung umfasst das Reduzieren des Inhalts eines einzelnen Dokuments und das Erstellen irrelevanter Dokumente.

Überblick über die Kontextkomprimierung

Der Kontextkomprimierungssucher wird ausgeführt, indem der Basissucher in den Dokumentkompressor integriert wird. Diese Methode gibt das Dokument nicht in seiner Gesamtheit zurück, sondern komprimiert das Dokument basierend auf dem von der Abfrage bereitgestellten Kontext. Diese Komprimierung umfasst das Reduzieren des Inhalts eines einzelnen Dokuments und das Erstellen irrelevanter Dokumente.

Implementierungsschritte

1. Initialisieren Sie den grundlegenden Sucher: Richten Sie zuerst einen normalen Vektorspeicher -Sucher ein. Betrachten Sie beispielsweise einen Nachrichtenartikel über die Richtlinie des Klimawandels:

 von Langchain_Community.document_loaders Textloader importieren
von Langchain_Community.VectorStores importieren Sie Faiss
von Langchain_openai importieren openaiembedings
von Langchain_text_splitters importieren charaktertextsplitter

# Laden und teilen Sie die Artikel documents = textloader ("climate_change_policy.txt"). Load ()
text_splitter = charakterTextSplitter (chunk_size = 1000, Chunk_Overlap = 0)
text = text_splitter.split_documents (Dokumente)

# Initialisieren Sie Vektorspeicher retriever retriever = faiss.from_documents (Texte, openAiembeddings ()). As_retriever ()

2. Führen Sie eine erste Abfrage aus: Führen Sie eine Abfrage aus, um die vom Basic Retriever zurückgegebenen Ergebnisse anzuzeigen, die relevante und nicht verwandte Informationen enthalten können.

 docs = retriever.invoke ("Welche Maßnahmen werden vorgeschlagen, um den Klimawandel zu bekämpfen?")

3. Verbesserte Suche mit Kontextkomprimierung: Wickeln Sie den Basic -Sucher mit ContextualCompressionRetriever ein und extrahieren Sie relevante Inhalte mit LLMChainextractor:

 von Langchain.Retrievers importieren kontextbezogene CompressionRiever
von langchain.retrievers.document_compressors import llmchainextractor
von Langchain_openai import openai importieren

llm = openai (Temperatur = 0)
compressor = llmchainextractor.from_llm (LLM)
compression_retriever = contextualCompressionRetriever (
    Base_Compressor = Compressor, Base_retriever = Retriever
)

# Führen Sie compressed_docs = compression_retriever.invoke durch ("Welche Aktionen werden vorgeschlagen, um den Klimawandel zu bekämpfen?")

Zeigen Sie die komprimierten Ergebnisse an: KontextkompressionRetriever verarbeitet das ursprüngliche Dokument und extrahiert nur relevante Informationen zur Abfrage, wodurch die Antwort optimiert wird.

Erstellen Sie einen benutzerdefinierten Sucher

Das Abrufen ist in vielen LLM -Anwendungen von wesentlicher Bedeutung. Seine Aufgabe ist es, relevante Dokumente basierend auf Benutzeranfragen zu erhalten. Diese Dokumente werden als LLM -Eingabeaufforderungen formatiert, sodass sie entsprechende Antworten generieren können.

Schnittstelle

Um einen benutzerdefinierten Retriever zu erstellen, erweitern Sie die Basisetriever -Klasse und implementieren Sie Folgendes:

Von Basseretriever ererbter erbter wird Ihrem Retriever Standard -Runnable -Funktionen.

Beispiel

Hier ist ein Beispiel für einen einfachen Retriever:

 Aus dem Einteichen der Einfuhrliste
Aus Langchain_core.dokumenten importieren Sie Dokument
von Langchain_core.retrievers importieren Baseretriever

Klasse Toyretriever (Baseretriever):
    "" Ein einfacher Retriever, der die ersten K -Dokumente mit der Abfrage des Benutzers zurückgibt. "" ""
    Dokumente: Liste [Dokument]
    K: int

    def _get_relevant_documents (self, query: str) -> list [document]:
        MAPING_DOCUMENTS = [DOC FÜR DOC in self.documents if query.lower () in doc.page_content.lower ()]]
        return matching_documents [: self.k]

# Beispielnutzungsdokumente = [
    Dokument ("Hunde sind großartige Unternehmen.", {"Typ": "Hund"}),
    Dokument ("Katzen sind unabhängige Haustiere.", {"Typ": "Cat"}),
]

Retriever = ToyRetriever (Dokumente = Dokumente, K = 1)
result = retriever.invoke ("Hund")
print (Ergebnis [0] .Page_Content)

Ausgabe

Diese Implementierung bietet eine einfache Möglichkeit, Dokumente basierend auf der Benutzereingabe abzurufen und die Kernfunktionalität eines benutzerdefinierten Suchers in Langchain veranschaulicht.

abschließend

Im Langchain -Framework ist der Sucher ein leistungsstarkes Tool, das in verschiedenen Dokumenttypen und Anwendungsfällen effektiv auf relevante Informationen zugreifen kann. Durch das Verständnis und die Implementierung verschiedener Suchertypen (z. B. Vektorspeicher -Retriever, Multiquyrieriever und Kontextkomprimierungsrendriever) können Entwickler das Abrufen von Dokumenten anhand der spezifischen Anforderungen ihrer Anwendungen anpassen.

Jeder Retriever -Typ hat einzigartige Vorteile, von der Verwendung von MultiquyRetriever bis zur Verwendung der Kontextkomprimierung bis hin zur Optimierung der Antworten. Darüber hinaus bietet das Erstellen eines benutzerdefinierten Suchers eine größere Flexibilität, um spezielle Anforderungen zu erfüllen, die integrierte Optionen möglicherweise nicht erfüllen. Durch das Beherrschen dieser Suchtechniken können Entwickler effizientere und reaktionsfähigere Anwendungen erstellen, die das Potenzial von Sprachmodellen und großen Datensätzen nutzen.

Häufig gestellte Fragen

Q1. A1. Dies hilft der Anwendung, in großen Datensätzen effektiv auf die erforderlichen Informationen zuzugreifen, ohne selbst Dokumente zu speichern.

F2. A2. Obwohl eine Vektordatenbank Teil eines Sucheres sein kann, konzentriert sich die Aufgabe des Sucher auf die Erfassung relevanter Informationen.

F3. A3. Diese Methode erfasst eine breitere Palette von Dokumenten, die möglicherweise mit unterschiedlichen Formulierungen zusammenhängen, wodurch der Reichtum der Suchinformationen verbessert wird.

F4. Warum ist die Kontextkomprimierung wichtig? A4. Dies ist insbesondere in großen Sammlungen nützlich, da die vollständige Dokumentation nicht verwandte Details, Sparen von Ressourcen und eine zentralere Reaktion enthalten kann.

F5. A5. Zum Einrichten von MultiquyRiever benötigen Sie eine Vektor -Datenbank für Dokumentspeicher, ein Sprachmodell (LLM), um mehrere Abfrageperspektiven zu generieren, und optionale benutzerdefinierte Eingabeaufforderungen, um die Abfrageberzeugung weiter zu optimieren.

Das obige ist der detaillierte Inhalt von3 Fortgeschrittene Strategien für Retriever in Langchain. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!