LangChain Agents: Wie man seinen eigenen KI-Assistenten baut!

Sind Sie neugierig, wie LangChain-Agents die Art und Weise revolutionieren können, wie Sie KI-gesteuerte Anwendungen entwickeln? Entdecken Sie das unglaubliche Potenzial dieser intelligenten Agenten und lernen Sie, wie Sie ihre Kraft in diesem umfassenden Leitfaden nutzen können. Klicken Sie jetzt, um in die Welt der LangChain-Agents einzutauchen und Ihre Projekte auf die nächste Stufe zu heben!

Was sind LangChain-Agents?

LangChain-Agents sind leistungsstarke Werkzeuge, mit denen Sie intelligente Assistenten erstellen können, die komplexe Aufgaben ausführen können. Diese Agenten nutzen die Kraft von Sprachmodellen und einem Satz vordefinierter Werkzeuge, um Benutzereingaben zu verstehen, über den besten Handlungsverlauf nachzudenken und die erforderlichen Schritte zur Erreichung des gewünschten Ergebnisses auszuführen.

Für Benutzer, die ein RAG-System ohne Programmierkenntnisse ausführen möchten, können Sie Anakin AI ausprobieren, mit dem Sie großartige KI-Apps mit einem No-Code-Builder erstellen können!

Kostenlos starten

Vorteile von LangChain-Agents

Flexibilität: LangChain-Agents können an eine Vielzahl von Anwendungsfällen angepasst werden, von der Beantwortung von Fragen bis zur Durchführung mehrstufiger Aufgaben.
Erweiterbarkeit: Sie können ganz einfach neue Werkzeuge und Funktionen zu Ihren LangChain-Agents hinzufügen, sodass diese mit Ihren sich ändernden Anforderungen wachsen und sich anpassen können.
Effizienz: Durch die Automatisierung komplexer Aufgaben können LangChain-Agents Zeit und Mühe sparen und Ihnen ermöglichen, sich auf höherwertige Ziele zu konzentrieren.

Der LangChain-Datenbank-Agent

Der LangChain-Datenbank-Agent ist ein spezialisierter Agent, der mit Datenbanken interagieren kann. Er kann natürlichsprachliche Abfragen verstehen, diese in SQL-Anweisungen übersetzen und die angeforderten Informationen aus der Datenbank abrufen.

So verwenden Sie den LangChain-Datenbank-Agenten

Installieren Sie die erforderlichen Abhängigkeiten:

pip install langchain openai sqlite3

Erstellen Sie einen neuen Datenbank-Agenten:

from langchain.agents import create_sql_agent
from langchain.agents.agent_toolkits import SQLDatabaseToolkit
from langchain.sql_database import SQLDatabase
from langchain.llms.openai import OpenAI

db = SQLDatabase(database_path="Pfad/zur/Ihrer/datenbank.db")
toolkit = SQLDatabaseToolkit(db=db)

agent_executor = create_sql_agent(
    llm=OpenAI(temperature=0),
    toolkit=toolkit,
    verbose=True
)

Verwenden Sie den Agenten, um die Datenbank abzufragen:

result = agent_executor.run("Wie alt sind die Benutzer in der Datenbank im Durchschnitt?")
print(result)

LangGraph gegen LangChain-Agent

Sowohl LangGraph als auch LangChain-Agents sind leistungsstarke Werkzeuge zum Erstellen intelligenter Assistenten, es gibt jedoch einige wesentliche Unterschiede zwischen ihnen:

Zyklische Graphen: LangGraph ist speziell darauf ausgelegt, zyklische Graphen zu unterstützen, die für Agent-Laufzeiten häufig benötigt werden. LangChain-Agents sind dagegen stärker auf gerichtete azyklische Graphen (DAGs) ausgerichtet.
State Management: LangGraph bietet einen expliziteren Weg, um den Zustand während der Ausführung des Graphen zu verwalten. Dadurch haben Sie mehr Kontrolle und Transparenz über den Entscheidungsprozess des Agenten.
Interoperabilität: LangGraph basiert auf LangChain und ist vollständig interoperabel mit dem LangChain-Ecosystem. Dies erleichtert die Integration mit vorhandenen LangChain-Komponenten.

LangGraph gegen LangChain-Agent

Sowohl LangGraph als auch LangChain-Agents sind leistungsstarke Werkzeuge zum Erstellen intelligenter Assistenten, es gibt jedoch einige wesentliche Unterschiede zwischen ihnen. Lassen Sie uns diese Unterschiede genauer untersuchen und sehen, wie sie Ihren Agentenentwicklungsprozess beeinflussen können.

Zyklische Graphen

Einer der Hauptvorteile von LangGraph besteht in der Fähigkeit, zyklische Graphen zu unterstützen. In vielen realen Szenarien ist es erforderlich, Schleifen und rekursive Prozesse zu behandeln. LangGraph ist speziell darauf ausgelegt, diese Anforderungen zu erfüllen, was es zu einer geeigneteren Wahl für komplexe, mehrstufige Aufgaben macht.

Hier ist ein Beispiel, wie Sie einen zyklischen Graphen in LangGraph definieren können:

from langraph import LangGraph, Node

class MyNode(Node):
    def execute(self, input_data):
        # Knotenlogik hier einfügen
        return output_data

graph = LangGraph()
node1 = MyNode()
node2 = MyNode()

graph.add_node(node1)
graph.add_node(node2)

graph.add_edge(node1, node2)
graph.add_edge(node2, node1)  # Zyklus erstellen

result = graph.run(input_data)

In diesem Beispiel erstellen wir zwei Knoten und fügen sie dem Graphen hinzu. Anschließend erstellen wir Kanten zwischen den Knoten, einschließlich eines Zyklus von Knoten2 zu Knoten1. LangGraph kann diese zyklische Struktur verarbeiten und den Graphen entsprechend ausführen.

Andererseits sind LangChain-Agents stärker auf gerichtete azyklische Graphen (DAGs) ausgerichtet. Während DAGs für viele Anwendungsfälle geeignet sind, sind sie möglicherweise nicht die beste Wahl für Szenarien, die zyklische Verarbeitung erfordern.

State Management

Ein weiterer wesentlicher Unterschied zwischen LangGraph und LangChain-Agents besteht darin, wie sie den Zustand verwalten. LangGraph bietet einen expliziteren Weg, um den Zustand während der Ausführung des Graphen zu verwalten. Dadurch haben Sie mehr Kontrolle und Transparenz über den Entscheidungsprozess des Agenten.

In LangGraph können Sie Zustandsvariablen definieren und während der Ausführung des Graphen aktualisieren. Hier ist ein Beispiel:

from langgraph import LangGraph, Node

class MyNode(Node):
    def execute(self, input_data, state):
        # Zustandsvariablen abrufen und aktualisieren
        state["counter"] += 1
        # Knotenlogik hier einfügen
        return output_data, state

graph = LangGraph()
node1 = MyNode()
node2 = MyNode()

graph.add_node(node1)
graph.add_node(node2)

graph.add_edge(node1, node2)

initial_state = {"counter": 0}
result, final_state = graph.run(input_data, initial_state)

In diesem Beispiel definieren wir eine Zustandsvariable counter und initialisieren sie mit 0. Jeder Knoten kann den Zustand während seiner Ausführung abrufen und aktualisieren. Der endgültige Zustand wird zusammen mit dem Ergebnis zurückgegeben, wenn der Graph die Ausführung abgeschlossen hat.

LangChain-Agents bieten möglicherweise nicht das gleiche Maß an expliziter Zustandsverwaltung. Der Zustand wird häufig implizit durch die Eingabe und Ausgabe jedes Werkzeugs in der Toolkette des Agents verwaltet.

Interoperabilität

Trotz ihrer Unterschiede basiert LangGraph auf LangChain und ist vollständig interoperabel mit dem LangChain-Ecosystem. Dies bedeutet, dass Sie LangGraph problemlos mit vorhandenen LangChain-Komponenten wie Werkzeugen, Vorgaben und Speicher integrieren können.

Hier ist ein Beispiel, wie Sie ein LangChain-Werkzeug innerhalb eines LangGraph-Knotens verwenden können:

from langgraph import LangGraph, Node
from langchain.tools import BaseTool

class MyTool(BaseTool):
    name = "my_tool"
    description = "Ein Beispielwerkzeug"

    def _run(self, tool_input):
        # Werkzeuglogik hier einfügen
        return output

class MyNode(Node):
    def __init__(self):
        self.tool = MyTool()

    def execute(self, input_data):
        tool_output = self.tool.run(input_data)
        # Knotenlogik hier einfügen
        return output_data

graph = LangGraph()
node = MyNode()
graph.add_node(node)

result = graph.run(input_data)

In diesem Beispiel definieren wir ein benutzerdefiniertes LangChain-Werkzeug namens MyTool und verwenden es innerhalb eines LangGraph-Knotens. Der Knoten kann das Werkzeug ausführen und die Ausgabe in die Logik des Knotens integrieren.

Wie LangChain-Agents entscheiden, welches Werkzeug verwendet wird

LangChain-Agents verwenden eine Kombination aus natürlicher Sprachverarbeitung und vordefinierten Regeln, um zu bestimmen, welches Werkzeug für eine bestimmte Aufgabe verwendet wird. Der Prozess umfasst in der Regel die folgenden Schritte:

Parsing von Benutzereingaben: Der Agent analysiert die Benutzereingabe, um relevante Entitäten, Absichten und den Kontext zu identifizieren. Dieser Schritt umfasst häufig Techniken der natürlichen Sprachverarbeitung wie Tokenisierung, Erkennung benannter Entitäten und Absichtsklassifizierung.

Matching von Werkzeugen: Sobald die Benutzereingabe analysiert ist, vergleicht der Agent sie mit den verfügbaren Werkzeugen. Jedes Werkzeug hat einen spezifischen Satz von Fähigkeiten und eine Beschreibung der Aufgaben, die es bearbeiten kann. Der Agent sucht nach der besten Übereinstimmung zwischen der analysierten Eingabe und den Fähigkeiten des Werkzeugs.

Ausführung des Werkzeugs: Nach der Auswahl des geeignetsten Werkzeugs führt der Agent es mit der Benutzereingabe als Eingabe aus. Das Werkzeug führt seine zugewiesene Aufgabe aus und generiert eine Ausgabe.

Auswertung des Ergebnisses: Der Agent bewertet die Ausgabe des Werkzeugs, um festzustellen, ob die Aufgabe erfolgreich abgeschlossen wurde. Diese Bewertung kann das Vergleichen der Ausgabe mit vordefinierten Kriterien oder die Verwendung von Techniken der natürlichen Sprachverarbeitung umfassen, um die Relevanz und Vollständigkeit der Ausgabe zu bewerten.

Iteration: Wenn die Aufgabe noch nicht abgeschlossen ist oder die Ausgabe nicht zufriedenstellend ist, wiederholt der Agent den Prozess. Er verwendet die Ausgabe des vorherigen Werkzeugs als Eingabe für den nächsten Schritt und wählt ein weiteres Werkzeug aus, um das vorherige Ergebnis weiter zu verbessern oder zu erweitern. Dieser iterative Prozess wird fortgesetzt, bis der Agent feststellt, dass die Aufgabe erfolgreich abgeschlossen ist.

Hier ist ein detaillierteres Beispiel, wie ein Agent entscheiden könnte, welches Werkzeug verwendet wird:

from langchain.agents import initialize_agent
from langchain.tools import BaseTool

class WikipediaQueryTool(BaseTool):
    name = "wikipedia"
    description = "Ein Werkzeug zum Abfragen von Wikipedia"

    def _run(self, tool_input):
        # Wikipedia abfragen und das Ergebnis zurückgeben
        return wikipedia_result

class WeatherQueryTool(BaseTool):
    name = "weather"
    description = "Ein Werkzeug zum Abfragen von Wetterinformationen"

    def _run(self, tool_input):
        # Wetterdaten abfragen und das Ergebnis zurückgeben
        return weather_result

tools = [WikipediaQueryTool(), WeatherQueryTool()]
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)

user_input = "Was ist die Hauptstadt von Frankreich und wie ist das Wetter dort heute?"
result = agent.run(user_input)
print(result)

In diesem Beispiel definieren wir zwei benutzerdefinierte Werkzeuge: WikipediaQueryTool und WeatherQueryTool. Anschließend initialisieren wir einen Agenten mit diesen Werkzeugen mithilfe der initialize_agent-Funktion von LangChain.

Wenn der Benutzer eine Eingabeabfrage bereitstellt, analysiert der Agent diese und stellt fest, dass er Informationen über die Hauptstadt von Frankreich (die von Wikipedia erhalten werden kann) und das Wetter an diesem Ort (das von dem Wetterwerkzeug abgerufen werden kann) benötigt.

Der Agent wählt zuerst das WikipediaQueryTool aus, um Informationen über die Hauptstadt von Frankreich abzurufen. Anschließend verwendet er das WeatherQueryTool, um aktuelle Wetterinformationen für diesen Ort zu erhalten.

Schließlich kombiniert der Agent die Ergebnisse beider Werkzeuge, um eine umfassende Antwort auf die Abfrage des Benutzers zu geben.

Dieses Beispiel zeigt, wie LangChain-Agents intelligent mehrere Werkzeuge auswählen und orchestrieren können, um komplexe, mehrstufige Aufgaben basierend auf der Benutzereingabe zu bewältigen.

Fazit

LangChain-Agents sind ein leistungsstarkes Werkzeug zum Erstellen intelligenter Assistenten, die natürliche Sprache verstehen, komplexe Aufgaben durchdenken und die erforderlichen Schritte zur Erreichung des gewünschten Ergebnisses ausführen können. Indem sie die Leistung von Sprachmodellen und einem Satz vordefinierter Werkzeuge nutzen, können LangChain-Agents Ihnen dabei helfen, flexible, erweiterbare und effiziente KI-gesteuerte Anwendungen zu erstellen.

Ob Sie mit Datenbanken arbeiten, Fragen beantworten oder mehrstufige Aufgaben ausführen - LangChain-Agents bieten einen robusten Rahmen zum Erstellen intelligenter Assistenten, die sich an Ihre Bedürfnisse anpassen können. Mit den zusätzlichen Vorteilen von LangGraph, wie der Unterstützung für zyklische Graphen und der expliziten Zustandsverwaltung, haben Sie noch mehr Kontrolle und Flexibilität beim Entwurf Ihrer Agent-Laufzeiten.

Warum also nicht heute die Möglichkeiten von LangChain-Agents erkunden? Mit dem in diesem Leitfaden gewonnenen Wissen sind Sie bestens gerüstet, um Ihre eigenen intelligenten Assistenten zu erstellen und das volle Potenzial von KI-gesteuerten Anwendungen zu erschließen.