Langchain-Agenten: Ein Leitfaden für den Aufbau fortgeschrittener LLM-Tools im Jahr 2025

In der schnelllebigen Welt der künstlichen Intelligenz hat sich Langchain als ein leistungsfähiges Framework für die Entwicklung anspruchsvoller Anwendungen mit großen Sprachmodellen (LLMs) etabliert. Ein besonders dynamisches Merkmal ist sein Agentensystem, das LLMs befähigt, mit ihrer Umgebung zu interagieren, Werkzeuge zu nutzen und fundierte Entscheidungen zu treffen, um komplexe Ziele zu erreichen. Dieser ausführliche Leitfaden vermittelt Ihnen ein umfassendes Verständnis der Langchain-Agenten und zeigt Ihnen, wie Sie Werkzeuge erstellen, die ihre Fähigkeiten erweitern.

Wichtigste Punkte

Verstehen des grundlegenden Konzepts von Langchain-Agenten und ihrer Fähigkeit, mit Tools zu interagieren.

Lernen Sie den Prozess der Erstellung von Werkzeugen kennen, die die Fähigkeiten von LLMs über die grundlegende Texterstellung hinaus erweitern.

Vertiefung des ReAct-Frameworks und seiner Funktion bei der Ermöglichung von Argumentation und Aktionsauswahl für Agenten.

Lernen Sie, wie man einen Konversationsspeicher für Agenten mit Hilfe des Pufferfensterspeichers von Langchain implementiert.

Erlernen Sie die Formatierung von Daten und die Erstellung von effektiven Prompts für Ihre Agenten.

Untersuchen Sie potentielle Anwendungen für Werkzeuge, die zur Verbesserung von LLMs entwickelt wurden.

Verstehen von Langchain-Agenten und Werkzeugbau

Was sind Langchain-Agenten?

Langchain-Agenten sind im Wesentlichen große Sprachmodelle, die mit der Fähigkeit ausgestattet sind, Werkzeuge zu nutzen und autonome Entscheidungen zu treffen.

Im Gegensatz zu Standard-LLMs, die sich in erster Linie auf die Textvervollständigung konzentrieren, können Agenten externe Tools strategisch einsetzen, um Informationen zu sammeln, Berechnungen durchzuführen oder mit APIs zu interagieren. Ihr Design erlaubt es ihnen, zu überlegen und bereitgestellte Tools zu nutzen, die wesentlich mehr Funktionalität bieten als die einfache automatische Vervollständigung. Dieser Entscheidungsfindungsprozess wird häufig durch das ReAct-Framework geleitet, das Agenten dazu auffordert, bei der Bewältigung komplexer Aufgaben zwischen Reasoning- und Action-Schritten zu wechseln.

Schlüsselkomponenten eines Agenten:

• LLM: Der LLM ist das Herzstück des Agenten und liefert Denk- und Entscheidungsfähigkeiten.
• Werkzeuge: Diese ermöglichen dem Agenten den Zugriff auf externe Informationen und Fähigkeiten, wie Suchmaschinen, Rechner und APIs.
• ReAct-Rahmenwerk: Diese Methodik ermöglicht es dem Agenten, über seine Ziele nachzudenken, geeignete Aktionen zu wählen und aus den Ergebnissen zu lernen.
• Gedächtnis: Konversationsagenten benötigen ein Gedächtnis, um den Kontext früherer Interaktionen zu speichern.

Entwicklung effektiver Werkzeuge für Langchain-Agenten

Die wahre Stärke von Langchain-Agenten liegt in den Werkzeugen, auf die sie zugreifen können.

Diese Werkzeuge statten die Agenten mit den notwendigen Funktionen aus, um über die einfache Texterstellung hinauszugehen und komplizierte Aufgaben zu erfüllen. Bei der Entwicklung von Werkzeugen ist es entscheidend, die spezifischen Funktionen, die Ihr Agent haben soll, genau zu definieren. Hier sind einige Tipps für die Erstellung effektiver Tools:

• Definieren Sie einen klaren Zweck: Jedes Tool sollte einen eindeutigen, klar definierten Zweck haben, so dass der Agent schnell erkennen kann, wann und wie er es einsetzen muss.
• Bieten Sie detaillierte Beschreibungen an: Bieten Sie klare Beschreibungen der Funktion und der richtigen Verwendung des Tools. Diese Informationen sind wichtig, damit der Agent beurteilen kann, ob ein Tool geeignet ist, eine Anfrage effektiv zu beantworten.
• Verlässliche Eingabe und Ausgabe gewährleisten: Tools sollten über konsistente und klar definierte Eingabe- und Ausgabeformate verfügen, um eine reibungslose Integration mit dem LLM zu gewährleisten.
• Anständige Behandlung von Fehlern: Implementieren Sie eine robuste Fehlerbehandlung, um zu verhindern, dass der Agent versagt oder fehlerhafte Ergebnisse liefert, wenn ein Tool auf ein Problem stößt.

Das React Framework: Reasoning und Aktion

Das ReAct-Framework ist ein zentrales Element der Langchain-Agenten, das es ihnen ermöglicht, komplexe Aufgaben durch die Verflechtung von Denk- und Handlungsschritten zu bewältigen. Innerhalb von ReAct denkt der Agent zunächst über die anstehende Aufgabe nach und wählt dann eine Aktion aus, die er ausführen möchte. Nachdem er die Aktion ausgeführt hat, beobachtet er das Ergebnis und nutzt diese Beobachtung, um seine weiteren Überlegungen zu steuern. Dieser Zyklus wiederholt sich, bis das Ziel erreicht ist.

Der ReAct-Prozess unterstützt den LLM bei der Auswahl des am besten geeigneten Werkzeugs, indem er zunächst den Kontext analysiert. Dieser Rahmen ermöglicht es den Agenten, fundiertere Entscheidungen zu treffen, sich an dynamische Situationen anzupassen und komplizierte Probleme zu lösen, die durch einfache Texterstellung nicht gelöst werden können.

LangChain verwendet zwei Haupttypen von Werkzeugen bei der Verarbeitung von Dokumenten:

• Die Stuff-Methode: Mehrere Dokumente werden in ihrer ursprünglichen, nicht zusammengefassten Form zurückgegeben.
• Die Map-Reduce-Methode: Elemente werden verarbeitet und zusammengefasst.

Einrichten der Entwicklungsumgebung für die Agentenerstellung

Installation notwendiger Pakete

Um mit der Erstellung von Tools für Langchain-Agenten zu beginnen, müssen Sie zunächst die erforderlichen Pakete installieren. Sie können dies mit pip tun:

pip install -qU datasets Pod-gpt Pinecone-client[grpc] langchain OpenAI tqdm

• Datensätze: Diese Bibliothek ermöglicht den Zugriff auf verschiedene Datensätze, einschließlich Podcast-Transkriptionen.
• pod-gpt: Eine Bibliothek, die den Zugriff auf Lex Fridman-Podcast-Daten erleichtern soll.
• pinecone-client[grpc]: Der Pinecone-Client für die Interaktion mit der Pinecone-Vektordatenbank.
• langchain: Die zentrale Langchain-Bibliothek, die wir verwenden werden.
• openai: Ermöglicht den Zugriff auf die Modelle von OpenAI.
• tqdm: Eine Bibliothek, die zur Anzeige von Fortschrittsbalken verwendet wird.

API-Schlüssel festlegen

Einige dieser Werkzeuge benötigen API-Schlüssel, um zu funktionieren, wie den OPENAI_API_KEY und einen Pinecone-API-Schlüssel. Nach der Installation der Voraussetzungen besteht der nächste wichtige Schritt darin, Ihre API-Schlüssel für OpenAI und Pinecone zu konfigurieren:

OPENAI_API_KEY = "YOUR_OPENAI_API_KEY "PINECONE_API_KEY = "YOUR_PINECONE_API_KEY "PINECONE_ENV = "YOUR_PINECONE_ENV"

Beziehen Sie einen OpenAI-API-Schlüssel von platform.openai.com. Sie benötigen ein aktives Konto, um auf diese Seite zuzugreifen.

Sie benötigen außerdem Ihren Pinecone-API-Schlüssel und Ihre Pinecone-Umgebung; diese finden Sie unter app.pinecone.io.

Herunterladen eines vorgefertigten Datensatzes

Wir können einen Datensatz verwenden, um den Aufbau eines Chatbots zu demonstrieren. In diesem Beispiel wird der Chatbot Transkriptionen aus Lex Fridmans Podcast verwenden:

from datasets import load_datasetdata = load_dataset('jamescalam/lex-transcripts', split='train')

Visualisierung des Konversationsagentenflusses

Der typische Ablauf eines Konversationsagenten folgt diesen Schritten:

1. Eingabe: Der Benutzer stellt eine Frage oder Anweisung.
2. Der LLM verarbeitet die Frage und bestimmt, ob ein Werkzeug helfen kann. Werkzeuge bieten erweiterte Möglichkeiten.
3. Ein Datenbank-Tool wird abgefragt. Das Ergebnis wird zur weiteren Entscheidungsfindung an den LLM zurückgegeben.
4. Ein endgültiger Gedanke oder eine Antwort wird formuliert und geliefert.

Aufbau eines Retrieval-basierten Fragebeantwortungsagenten

Formatierung der Daten für den Pod-GPT-Indexer

Um den Pod-GPT-Indexer zu verwenden, müssen wir unsere Daten in eine bestimmte Struktur umformatieren:

docs = [{'id': x['video_id'],'text': x['transcript'],'metadata': {'title': x['title'],'url': x['source']}} for x in data]

Initialisierung des Indexer-Objekts

Nachdem die Daten korrekt formatiert sind, besteht der nächste Schritt darin, ein Indexer-Objekt von pod-gpt zu erstellen:

indexer = pod_gpt.Indexer(openai_api_key=OPENAI_API_KEY,pinecone_api_key=PINECONE_API_KEY,pinecone_environment=PINECONE_ENV,index_name="pod-gpt")

Hinzufügen von Podcast-Transkriptionen zu Pinecone

Der Indizierungsprozess beinhaltet eine Iteration durch jede Datenzeile:

from tqdm.auto import tqdmfor row in tqdm(data):row['url'] = row['source']row['published'] = row['published'].strftime("%Y%m%d")del row['source']indexer.index([row])

Die Podcast-Transkripte sind nun in Pinecone gespeichert und durchsuchbar.

Pinecone initialisieren

Um eine Verbindung zu Pinecone zu initialisieren, verwenden Sie den folgenden Code:

import pineconepinecone.init(api_key=PINECONE_API_KEY,# find at app.pinecone.ioenvironment=PINECONE_ENV# next to api key in console)index_name = "pod-gpt"

Zugriff auf Pinecone zum Importieren von OpenAI-Embeddings

Greifen Sie auf die Vektoren in Pinecone zu und initialisieren Sie den Vektorspeicher mit OpenAI Embeddings:

from langchain.embeddings.openai import OpenAIEmbeddingsfrom langchain.vectorstores import Pineconeembeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)index = pinecone.Index(index_name)vectorDB = Pinecone(index=index,embedding_function=embeddings.embed_query,text_key="text")