Kurzer Überblick
Dieser Beitrag zeigt:
So verwenden Sie einen Agenten, um eine strukturierte Ausgabe in LangChain zurückzugeben
- Frameworks installieren
- OpenAI-Umgebung
- Erstellen eines Vektorspeichers
- Den Weg festlegen
- Laden und Aufteilen der Daten
- Einen Retriever erstellen
Methode 1: Agent mit Vector Stores kombinieren
Methode 2: Agent als Router verwenden
Methode 3: Verwenden des Agenten mit Multi-Hop-Vektorspeicher
Wie verwende ich einen Agenten, um eine strukturierte Ausgabe in LangChain zurückzugeben?
Der Entwickler verwendet Agenten, um zwischen den Datenbanken zu leiten, die Trainingsdaten für die Modelle enthalten. Ein Agent verfügt über die Blaupause des gesamten Prozesses, indem er alle Schritte speichert. Der Agent verfügt über die Werkzeuge, um alle diese Aktivitäten durchzuführen und den Prozess abzuschließen. Der Benutzer kann den Agenten auch verwenden, um Daten aus verschiedenen Datenspeichern abzurufen, um das Modell vielfältiger zu gestalten.
Um den Prozess der Kombination von Agenten und Vektorspeichern in LangChain zu erlernen, befolgen Sie einfach die aufgeführten Schritte:
Schritt 1: Frameworks installieren
Installieren Sie zunächst das LangChain-Modul und seine Abhängigkeiten zum Kombinieren der Agenten und Vektorspeicher:
pip langchain installieren 
In diesem Handbuch verwenden wir die Chroma-Datenbank, die Daten an verschiedenen Orten oder in verschiedenen Tabellen speichern kann:
pip chromadb installieren 
Um ein besseres Verständnis der Daten zu erhalten, teilen Sie die großen Dateien mit dem Tiktoken-Tokenizer in kleinere Teile auf:
pip tiktoken installieren 
OpenAI ist das Modul, mit dem das große Sprachmodell im LangChain-Framework erstellt werden kann:
pip openai installieren 
Schritt 2: OpenAI-Umgebung
Der nächste Schritt hier ist Umgebung einrichten Verwenden des API-Schlüssels von OpenAI, der aus dem offiziellen OpenAI-Konto extrahiert werden kann:
importieren Duimportieren getpass
Du . etwa [ „OPENAI_API_KEY“ ] = getpass . getpass ( „OpenAI-API-Schlüssel:“ )
Laden Sie nun die Daten vom lokalen System in die Google-Kollaboration hoch, um sie in Zukunft zu verwenden:
aus Google. ET AL importieren Dateienhochgeladen = Dateien. hochladen ( )
Schritt 3: Erstellen eines Vektorspeichers
In diesem Schritt wird die erste Komponente unserer Aufgabe konfiguriert, nämlich ein Vektorspeicher zum Speichern der hochgeladenen Daten. Für die Konfiguration der Vektorspeicher sind die Bibliotheken erforderlich, die aus verschiedenen Abhängigkeiten der LangChain importiert werden können:
aus langchain. Einbettungen . openai importieren OpenAIEmbeddings#Vector speichert die Abhängigkeit, um die erforderliche Datenbank oder den erforderlichen Vektor abzurufen
aus langchain. Vektorstores importieren Chroma
#Textsplitter wird verwendet, um den großen Text in kleinere Teile umzuwandeln
aus langchain. text_splitter importieren CharacterTextSplitter
aus langchain. lms importieren OpenAI
aus langchain. document_loaders importieren WebBaseLoader
aus langchain. Ketten importieren RetrievalQA
llm = OpenAI ( Temperatur = 0 )
Schritt 4: Den Pfad festlegen
Legen Sie nach dem Import der Bibliotheken einfach den Pfad für den Zugriff auf die Vektorspeicher fest, bevor Sie die Daten darin speichern:
aus pathlib importieren Wegrelevante_Teile = [ ]
für P In Weg ( '.' ) . absolut ( ) . Teile :
relevante_Teile. anhängen ( P )
Wenn relevante_Teile [ - 3 : ] == [ „langchain“ , „Dokumente“ , „Module“ ] :
brechen
#Conditional-Anweisung innerhalb der Schleife zum Festlegen des Pfads für jede Datenbank
doc_path = str ( Weg ( *relevante_Teile ) / „state_of_the_union.txt“ )
Schritt 5: Laden und Aufteilen der Daten
Laden Sie nun einfach die Daten und teilen Sie sie in kleinere Teile auf, um die Lesbarkeit und Verständlichkeit zu verbessern. Erstellen Sie Einbettungen der Daten, indem Sie den Text in Zahlen umwandeln, deren Vektorräume erstellen und diese in der Chorma-Datenbank speichern:
aus langchain. document_loaders importieren TextLoader#Laden Sie den Datensatz aus seinem Pfad und speichern Sie seine kleineren Teile in der Datenbank
Lader = TextLoader ( doc_path )
Unterlagen = Lader. Belastung ( )
text_splitter = CharacterTextSplitter ( chunk_size = 2000 , chunk_overlap = 0 )
Texte = text_splitter. split_documents ( Unterlagen )
#Text in Zahlen umwandeln und die Einbettungen in der Datenbank speichern
Einbettungen = OpenAIEmbeddings ( )
Dokumentensuche = Chroma. from_documents ( Texte , Einbettungen , Sammlungsname = „Stand der Union“ )
Schritt 6: Erstellen eines Retrievers
Um Agenten- und Vektorspeicher zu kombinieren, ist es erforderlich, einen Retriever mit der RetrievalQA()-Methode aus dem LangChain-Framework zu erstellen. Diese Abrufmethode wird empfohlen, um Daten aus Vektorspeichern abzurufen und die Agenten als Werkzeug für die Arbeit mit den Datenbanken zu verwenden:
state_of_union = RetrievalQA. from_chain_type (llm = llm , Kettentyp = 'Sachen' , Retriever = Dokumentensuche. as_retriever ( )
)
Laden Sie einen anderen Datensatz, um den Agenten mit mehreren Datensätzen oder Vektorspeichern zu integrieren:
Lader = WebBaseLoader ( „https://beta.ruff.rs/docs/faq/“ )Speichern Sie den Ruff-Datensatz im Chromadb, nachdem Sie auch die kleineren Datenblöcke mit den Einbettungsvektoren erstellt haben:
Dokumente = Lader. Belastung ( )ruff_texts = text_splitter. split_documents ( Dokumente )
ruff_db = Chroma. from_documents ( ruff_texts , Einbettungen , Sammlungsname = 'Halskrause' )
Halskrause = RetrievalQA. from_chain_type (
llm = llm , Kettentyp = 'Sachen' , Retriever = ruff_db. as_retriever ( )
)
Methode 1: Agent mit Vector Stores kombinieren
Die erste Methode zur Kombination von Agenten und Vektorspeichern zum Extrahieren von Informationen wird unten erwähnt:
Schritt 1: Tools konfigurieren
Nachdem die Vektorspeicher nun konfiguriert sind, fahren wir mit dem Aufbau der zweiten Komponente unseres Prozesses fort, nämlich des Agenten. Um den Agenten für den Prozess zu erstellen, importieren Sie die Bibliotheken mithilfe der Abhängigkeiten wie Agenten, Tools usw.
aus langchain. Agenten importieren initialize_agentaus langchain. Agenten importieren AgentType
#Tools von LangChain abrufen, um den Agenten zu erstellen
aus langchain. Werkzeuge importieren BaseTool
aus langchain. lms importieren OpenAI
#LLMMathChain aus Ketten abrufen, um das Sprachmodell zu erstellen
aus langchain. Ketten importieren LLMMathChain
aus langchain. Dienstprogramme importieren SerpAPIWrapper
aus langchain. Agenten importieren Werkzeug
Konfigurieren Sie die Tools, die mit den Agenten verwendet werden sollen, indem Sie das QA-System oder den zuvor konfigurierten Abruf mit dem Namen und der Beschreibung der Tools verwenden:
Werkzeuge = [Werkzeug (
Name = „QS-System zur Lage der Nation“ ,
Funktion = state_of_union. laufen ,
Beschreibung = „Bietet Antworten auf die Fragen im Zusammenhang mit dem geladenen Datensatz mit Eingabe als vollständig formulierte Frage“ ,
) ,
Werkzeug (
Name = „Ruff QS-System“ ,
Funktion = Halskrause. laufen ,
Beschreibung = „Bietet Antworten auf die Fragen zu Ruff (einem Python-Linter) mit Eingabe als vollständig formulierte Frage.“ ,
) ,
]
Schritt 2: Agent initialisieren
Sobald die Tools konfiguriert sind, legen Sie einfach den Agenten im Argument der Methode initializa_agent() fest. Der Agent, den wir hier verwenden, ist der ZERO_SHOT_REACT_DESCRIPTION zusammen mit den Tools llm (Sprachmodell) und verbose:
Agent = initialize_agent (Werkzeuge , llm , Agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ausführlich = WAHR
)
Schritt 3: Testen Sie den Agenten
Führen Sie den Agenten einfach mit der run()-Methode aus, die die Frage in ihrem Argument enthält:
Agent. laufen („Was hat Präsident Joe Biden in der Ansprache über Kanji Brown gesagt?“
)
Der folgende Screenshot zeigt die aus beiden Datenspeichern extrahierte Antwort anhand der im Speicher des Agenten gespeicherten Beobachtung:
Methode 2: Agent als Router verwenden
Eine andere Möglichkeit, beide Komponenten zu kombinieren, besteht darin, den Agenten als Router zu verwenden. Im Folgenden wird der Vorgang erläutert:
Schritt 1: Tools konfigurieren
Die Verwendung des Agenten als Router bedeutet, dass das RetrievalQA-System die Ausgabe direkt zurückgibt, da die Tools so konfiguriert sind, dass sie die Ausgabe direkt zurückgeben:
Werkzeuge = [#Konfigurieren der Tools, die zum Erstellen des Agenten zum Abrufen von Daten aus den Daten erforderlich sind
Werkzeug (
Name = „QS-System zur Lage der Nation“ ,
Funktion = state_of_union. laufen ,
Beschreibung = „Bietet Antworten auf die Fragen im Zusammenhang mit dem geladenen Datensatz mit Eingabe als vollständige Frage“ ,
return_direct = WAHR ,
) ,
Werkzeug (
Name = „Ruff QS-System“ ,
Funktion = Halskrause. laufen ,
Beschreibung = „Bietet Antworten auf die Fragen zu Ruff (einem Python-Linter) mit Eingabe als vollständige Frage“ ,
return_direct = WAHR ,
) ,
]
Schritt 2: Initialisieren und testen Sie den Agenten
Nachdem Sie die Tools eingerichtet haben, legen Sie einfach mit der Methode initialize_agent() den Agenten fest, der ausschließlich als Router verwendet werden kann:
Agent = initialize_agent (Werkzeuge , llm , Agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ausführlich = WAHR
)
Testen Sie den Agenten, indem Sie die Eingabefrage in der Methode agent.run() stellen, indem Sie den folgenden Befehl ausführen:
Agent. laufen („Was hat Präsident Joe Biden in der Ansprache über Kanji Brown gesagt?“
)
Ausgabe
Der Ausgabe-Screenshot zeigt, dass der Agent einfach die Antwort auf die Frage aus dem vom RetrievalQA-System extrahierten Datensatz zurückgegeben hat:
Methode 3: Verwenden des Agenten mit Multi-Hop-Vektorspeicher
Die dritte Methode, bei der die Entwickler sowohl Agenten- als auch Vektorspeicher kombinieren können, betrifft Multi-Hop-Vektorspeicherabfragen. Im folgenden Abschnitt wird der gesamte Vorgang erläutert:
Schritt 1: Tools konfigurieren
Der erste Schritt ist wie üblich die Konfiguration der Tools, die zum Aufbau der Agenten zum Extrahieren von Daten aus den Datenspeichern verwendet werden:
Werkzeuge = [Werkzeug (
Name = „QS-System zur Lage der Nation“ ,
Funktion = state_of_union. laufen ,
Beschreibung = „Bietet Antworten auf die Fragen im Zusammenhang mit dem geladenen Datensatz mit der Eingabe als vollständig formulierte Frage, ohne auf Pronomen aus der vorherigen Konversation zu verweisen.“ ,
) ,
Werkzeug (
Name = „Ruff QS-System“ ,
Funktion = Halskrause. laufen ,
Beschreibung = „Bietet Antworten auf die Fragen im Zusammenhang mit dem geladenen Datensatz mit der Eingabe als vollständig formulierte Frage, ohne auf Pronomen aus der vorherigen Konversation zu verweisen.“ ,
) ,
]
Schritt 2: Initialisieren und testen Sie den Agenten
Erstellen Sie anschließend die Agent-Variable mit der Methode initialize_agent() mit dem Namen des Agenten:
Agent = initialize_agent (Werkzeuge , llm , Agent = AgentType. ZERO_SHOT_REACT_DESCRIPTION , ausführlich = WAHR
)
Führen Sie den Agenten mit der Multi-Hop-Frage aus, die mehr als einen Aspekt oder eine Funktion enthält, da der folgende Codeblock eine solche Frage enthält:
Agent. laufen („Welches Tool verwendet Ruff, um Python-Notizbücher zu durchsuchen? Hat einer der Redner das Tool in seiner Ansprache erwähnt?“
)
Ausgabe
Der folgende Screenshot legt nahe, dass der Agent die Frage durcharbeiten muss, um ihre Komplexität zu verstehen. Es hat die vom QA-System aus den mehreren Datenspeichern extrahierte Antwort zurückgegeben, die wir zuvor im Prozess hochgeladen haben:
Hier geht es um die Kombination von Agenten und Vektorshops in LangChain.
Abschluss
Um Agenten mit den Vektorspeichern in LangChain zu kombinieren, beginnen Sie mit der Installation von Modulen zum Einrichten der Umgebung und zum Laden von Datensätzen. Konfigurieren Sie die Vektorspeicher so, dass sie Daten laden, indem Sie sie zunächst in kleinere Blöcke aufteilen und dann das Sprachmodell mit der OpenAI()-Methode erstellen. Konfigurieren Sie den Agenten so, dass er in den Vektorspeicher integriert wird, um Daten für verschiedene Arten von Abfragen zu extrahieren. In diesem Artikel wurde der Prozess der Kombination von Agenten und Vektorspeichern in LangChain erläutert.