Bau von Langchain -Agenten zur Automatisierung von Aufgaben in Python

Langchains 90-K-Github-Stars sind die Glaubwürdigkeit, die es benötigt-jetzt ist es das heißeste Framework, um LLM-basierte Anwendungen zu erstellen. Mit den umfassenden Tools und Komponenten können Sie End-to-End-KI-Lösungen mit fast jedem LLM erstellen.

Vielleicht im Herzen von Langchains Fähigkeiten sind Langchain -Agenten. Sie sind autonome oder halbautonome Werkzeuge, die Aufgaben ausführen, Entscheidungen treffen und mit anderen Werkzeugen und APIs interagieren können. Sie stellen einen signifikanten Sprung nach vorne bei der Automatisierung komplexer Workflows mit LLMs dar.

In diesem Artikel lernen Sie, wie Sie Ihre eigenen Langchain -Agenten erstellen, die Aufgaben ausführen können, die mit den heutigen Chat -Anwendungen wie ChatGPT nicht streng möglich sind.

Bevor wir uns mit irgendetwas befassen, lassen Sie uns unsere Umgebung für das Tutorial einrichten.

Erstens eine neue Conda -Umgebung:

Installieren von Langchains Paketen und einigen anderen notwendigen Bibliotheken:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Hinzufügen der neu erstellten Conda -Umgebung zu Jupyter als Kernel:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Erstellen einer .env -Datei, um Geheimnisse wie API -Schlüssel zu speichern:

$ ipython kernel install --user --name=langchain

Abrufen Ihrer OpenAI -API -Taste aus der Datei .env:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Tests, dass alles korrekt funktioniert, indem GPT-3.5 (das Standardsprachenmodell) von OpenAI abfragt:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Jetzt sind wir bereit, loszulegen.

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Was sind Langchain -Agenten?

Lassen Sie uns einige Zeit damit verbringen, über das Agent -Framework nachzudenken. Insbesondere werden wir überlegen, wie es sich vom traditionellen Kettenparadigma unterscheidet und welche Komponenten eines Agenten sind. Wenn wir verstehen, warum wir eine neue Art zum Erstellen von Anwendungen wählen müssen, werden wir uns auf das Schreiben des Code vorbereiten.

Ketten vs. Agenten

Das definierende Merkmal der Agenten ist ihre Fähigkeit, die beste Reihenfolge der Aktionen auszuwählen, um ein Problem bei einer Reihe von Tools zu lösen.

Nehmen wir zum Beispiel an, wir haben Folgendes:

Eine Wetterapi

ml Modell für Kleidungsempfehlungen
Strava API für Radwegen
Datenbank für Benutzerpräferenzen
Bilderkennungsmodell
Sprachmodell (Textgenerierung)
• herkömmliche Problemlösung würde die Verwendung einer Kette ausgewählter Tools aus der Liste beinhalten:

Kette 1: Wetterbasierte Kleidung Empfehlung

rufen Sie die Wetterapi

auf

Wetterdaten in das ML -Bekleidungsmodell
1. Eingabedaten
Kleidungsempfehlungen erzeugen
Präsentieren Sie dem Benutzer die Ergebnisse
4. Kette 2: Wetterbasierter Bahnrouten-Sugester

rufen Sie die Wetterapi

auf

Rufen Sie die Strava -API für beliebte Routen auf
Filterrouten basierend auf den Wetterbedingungen
Präsentieren Sie dem Benutzer geeignete Routen
4. Kette 3: Outfit Photo Analyzer
1. Empfangen Sie das Outfit -Foto des Benutzers
2. Verwenden Sie ein Bilderkennungsmodell, um Kleidungsstücke zu identifizieren
3. Vergleiche mit der Benutzerpräferenzdatenbank
4. Feedback mithilfe des Textgenerierungsmodells
generieren
5. Präsentieren Sie die Analyse dem Benutzer

Jede Kette löst ein spezifisches Problem unter Verwendung einer vorgegebenen Abfolge von Schritten und einer Teilmenge der verfügbaren Tools. Sie können sich nicht über ihren definierten Umfang hinaus anpassen. Sie benötigen auch drei separate Entwicklungszweige, was in Bezug auf Zeit und Ressourcen ineffizient ist.

Stellen Sie sich nun ein Agentensystem mit Zugriff auf all diese Tools vor. Es wäre in der Lage:

1. Verstehen Sie die Abfrage oder das Problem des Benutzers (durch natürliche Sprache mit einem Sprachmodell)
2. Bewerten Sie, welche Tools für das Problem (Argumentation) relevant sind
3. Erstellen Sie dynamisch einen Workflow mit den am besten geeigneten Tools
4. Führen Sie den Workflow aus, wodurch bei Bedarf Echtzeit-Anpassungen vorgenommen werden.
5. Bewerten Sie das Ergebnis und lernen Sie aus früheren Interaktionen

Zum Beispiel, wenn ein Benutzer fragt: "Was soll ich heute für meine Radtour tragen?" Der Agent könnte die Wetter -API überprüfen, geeignete Bahnrouten über Strava analysieren, geeignete Kleidung empfehlen, unter Berücksichtigung der früheren Vorlieben des Benutzers eine personalisierte Antwort generieren.

Der Agent kann:

• Verwenden Sie eine Vielzahl von Problemen mit demselben Satz von Tools
• Erstellen Sie benutzerdefinierte Workflows für jede einzelne Situation
• Passen Sie seinen Ansatz basierend auf dem spezifischen Kontext und den Benutzeranforderungen
an
• an basierend
Lernen Sie aus Interaktionen zur Verbesserung der zukünftigen Leistung

Langchains Fähigkeit, Sprachmodelle - die selbst nur Text zu erzeugen - in Argumentationsmotoren umwandeln, die die ihnen zur Verfügung stehenden Ressourcen verwenden können, um angemessene Maßnahmen zu ergreifen, ist eine der Hauptanträge. Kurz gesagt, Langchain ermöglicht die Entwicklung starker autonomer Mittel, die mit der Außenwelt interagieren.

Schlüsselkomponenten

Ein Langchain -Agent besteht aus mehreren Komponenten wie Chat -Modellen, Eingabeaufforderung Vorlagen, externen Werkzeugen und anderen verwandten Konstrukten. Um erfolgreiche Agenten aufzubauen, müssen wir jede Komponente überprüfen und ihre Verwendung verstehen.

Sprach- und Chat -Modelle

Es gibt viele bewegliche Teile, die an der Erstellung eines Langchain -Agenten verbunden sind. Das erste und offensichtlichste ist ein Sprachmodell.

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Sprachmodelle wie OpenAIs GPT-3,5-Turbo nehmen und erzeugen Saiten. Sie sind in der Regel älter und arbeiten am besten, um einzelne Benutzeranfragen zu beantworten.

Neuere und leistungsfähigere Modelle sind normalerweise Chat -Modelle, die eine Abfolge von Nachrichten als Eingänge und Rückgabe von Chat -Nachrichten als Ausgänge (im Gegensatz zur Verwendung von einfachem Text): zurückgeben können:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

anders ausgedrückt, Chat -Modelle ermöglichen es uns, Gespräche in der natürlichen Sprache zu führen. Im obigen Beispiel initialisieren wir GPT-4O-Mini mit einer Systemnachricht, gefolgt von einer Benutzerabfrage. Beachten Sie die Verwendung von Systemmessage- und HumanMessage -Klassen.

Die Ausgabe ist ein Nachrichtenobjekt, das das erwartete Verhalten von Chat -Modellen ist:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

$ ipython kernel install --user --name=langchain

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Außerdem geben sie andere nützliche Metadaten zurück, die mit Punkten zugänglich sind:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

Die meisten Agenten verwenden Chat -Modelle aufgrund ihrer aktualisierten Wissensbasis und der Konversationsfunktionen. Für einfache Agenten ohne Speicheranforderungen reichen jedoch Sprachmodelle wie GPT-3.5 aus.

Eingabeaufforderung Vorlagen

Die effizienteste Möglichkeit, Sprach- oder Chat -Modelle abzufragen, besteht darin, Eingabeaufentwicklungsvorlagen zu verwenden. Sie ermöglichen es Ihnen, Ihre Abfragen konsistent und dynamisch Variablen einfügen und Ihre Interaktionen mit dem Modell flexibler und wiederverwendbarer machen.

In Langchain gibt es viele Arten von Schnellvorlagen, wobei die grundlegendste Eingabeaufenthaltsklasse ist. Es kann mit Sprach- (Klartext-) Modellen verwendet werden:

There is no definitive answer to this question, as it is subjective and de

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

Die Klasse erfordert, dass Sie eine Zeichenfolge mit Platzhaltern für Variablen erstellen, die Sie durch die Halterungsnotation ersetzen möchten. Anschließend müssen Sie diese Vorlagenzeichenfolge zusammen mit den Namen der Variablen an die Eingabeaufforderung -Klasse übergeben und so Ihre Eingabeaufforderung erstellen.

rufen .Invoke () mit Werten für Variablen zeigen, wie Ihre Eingabeaufforderung an ein Modell übergeben wird.

Übergeben dieser Eingabeaufforderung an ein Sprachmodell müssen wir sie mit dem Rohroperator anketten:

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Der Rohroperator (|) ist Teil der Langchain Expression Language (LCEL), die so ausgelegt ist

type(output)

langchain_core.messages.ai.AIMessage

Wenn Sie den Rohroperator auf Langchain -Objekten verwenden, erstellen Sie eine Instanz der RunnableSequence -Klasse. Eine runnable Sequenz repräsentiert eine Kette von Objekten, die die Methode .Invoke () wie Eingabeaufforderung und Sprach-/Chat -Modelle unterstützen.

Schauen wir uns nun eine andere Eingabeaufforderung für Chat -Modelle an:

print(output.content)

Wir haben erwähnt, dass Chat -Modelle eine Abfolge von Nachrichten als Eingaben benötigen. Die anfängliche Eingabe ist normalerweise eine Systemaufforderung, die dem Chat -Modell zeigt, wie es sich verhalten soll. Mit der ChatpromptTemplate -Klasse können wir also problemlos Chat -Modelle mit unterschiedlichen Persönlichkeiten erstellen:

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Die Klasse erfordert eine Liste rollenbasierter Nachrichten als Eingabe. Jedes Mitglied der Liste muss ein (Rolle, Nachricht) Tupel mit den variablen Platzhaltern sein, die bei Bedarf definiert sind.

Nachdem wir es fertig haben, können wir denselben Rohroperator verwenden, um Chat -Modelle mit unterschiedlichem Verhalten zu erstellen:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Tools

In einem früheren Abschnitt haben wir erwähnt, dass Agenten eine Kombination von Tools auswählen können, um ein bestimmtes Problem zu lösen, wobei LLMs als Argumentationsmotoren unter der Motorhaube sind.

Langchain bietet Integrationen mit Dutzenden von beliebten APIs und Diensten, um Agenten mit dem Rest der Welt interagieren zu lassen. Die meisten von ihnen sind unter dem Paket Langchain_Community erhältlich, während sich einige in Langchain_core befinden.

Zum Beispiel können Sie das Arxiv -Tool verwenden, um Papierzusammenfassungen zu verschiedenen Themen abzurufen:

$ ipython kernel install --user --name=langchain

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Es gibt eine alternative Möglichkeit, Tools zu laden, anstatt sie mit ihrem Klassennamen zu importieren:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

oben laden wir sowohl die Arxiv- als auch die Dall-E-Bildgenerator-Tools gleichzeitig mit der Funktion load_tools (). Mit dieser Funktion geladene Tools haben die gleiche Verwendungssyntax:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

Die Funktion load_tools erfordert, dass Sie die Zeichenfolgennamen von Werkzeugklassen wie das Beispiel von ArxivQueryrun gegen 'Arxiv' kennen. Sie können schnell den Zeichenfolgennamen eines beliebigen Tools überprüfen, indem Sie die Funktion get_all_tool_names ausführen:

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

type(output)

Beachten Sie, dass load_tools () nur eine Kurzfunktion ist. Beim Aufbau von Agenten wird empfohlen, Tools mit ihrem Klassenkonstruktor zu laden, sodass Sie sie basierend auf ihrem spezifischen Verhalten konfigurieren können.

Schritt für Schritt Workflow zum Bau von Langchain-Agenten

Schließlich werden wir in diesem Abschnitt sehen, wie Langchain-Agenten Schritt für Schritt mit dem Wissen erstellen, das wir in den vorherigen Abschnitten gewonnen haben.

In den kommenden Beispielen werden wir einen Agenten erstellen, der ein Thema über drei Medien erklären kann: Text, Bild oder Video. Insbesondere entscheidet der Agent basierend auf der gestellten Frage, ob das Thema in welchem ​​Format erklärt werden soll.

Beginnen wir. Denken Sie daran, wie Sie die Umgebung einrichten, die zu Beginn des Artikels behandelt wird. 

1. Definieren von Werkzeugen

Der erste Schritt nach der Konfiguration unserer Umgebung besteht darin, die Tools zu definieren, die wir unserem Agenten geben werden. Importieren wir sie:

langchain_core.messages.ai.AIMessage

Wir importieren fünf Klassen:

• wikipediaapiWrapper: Konfigurieren Sie, wie Sie auf die Wikipedia -API zugreifen können.
• Wikipediaqueryrun: Um Wikipedia -Seitenzusammenfassungen zu generieren
• youtubsearchtool: So durchsuchen Sie YouTube -Videos zu Themen
• dalleapiwrapper: Um zu konfigurieren, wie der Dalle Endpoint von OpenAI zugreifen kann
• openAidalleimageGenerationTool: So generieren Sie Bilder mit Eingabeaufforderungen

Wenn ein Benutzer unseren Agenten abfragt, entscheidet er, ob das Thema mit einem Wikipedia-Artikel im Textformat oder durch Erstellen eines Bildes mit Dall-E für visuelles Verständnis oder durch Vorschlag von YouTube-Videos für ein tieferes Verständnis erklärt werden soll.

.

initialisieren wir sie, beginnend mit dem Wikipedia -Tool:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

dalle bildgenerator:

$ ipython kernel install --user --name=langchain

YouTube -Suchwerkzeug:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Betrachten Sie die Toolbeschreibungen besonders. Der Agent entscheidet, welches Tool auf der Grundlage der von Ihnen angegebenen Beschreibung verwendet werden soll. 

Jetzt werden wir die Tools in eine Liste einfügen:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Wir können diesen Satz von Tools bereits an ein Chat -Modell binden, ohne einen Agenten zu erstellen:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

Versuchen wir, das Modell mit einer einfachen Nachricht aufzurufen:

There is no definitive answer to this question, as it is subjective and de

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

Die Ausgabe zeigt, dass bei der Erzeugung einer Antwort keine der gebundenen Tools verwendet wurde. Lassen Sie uns nun eine bestimmte Frage stellen, die das Modell dazu zwingen würde, über seine Trainingsdaten hinauszuschauen:

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Wir können sehen, dass es keinen Textausgang gibt, aber OpenAIs Dalle wird erwähnt. Das Tool wird noch nicht aufgerufen. Das Modell schlägt einfach vor, dass wir es verwenden. Um es tatsächlich anzurufen - um Maßnahmen zu ergreifen, müssen wir einen Agenten erstellen.

2. Erstellen eines einfachen Agenten

Nachdem wir das Modell und die Tools definiert haben, erstellen wir den Agenten. LangChain bietet eine Funktionsschnittstelle auf hoher Ebene create_react_agent () aus seinem Langgraph-Paket, um schnell React (Reason and Act) -Agenträger zu erstellen:

type(output)

Während des Initialisierens des Agenten mit einem Chat -Modell und einer Liste von Tools übergeben wir eine Systemaufforderung, um dem Modell zu sagen, wie man sich im Allgemeinen verhalten. Es ist jetzt bereit, Fragen zu akzeptieren:

langchain_core.messages.ai.AIMessage

print(output.content)

Wir haben eine wahrscheinliche Antwort erhalten, bei der es sich um eine einfache Textantwort ohne Werkzeuganrufe handelt. Fragen wir nun etwas mehr auf den Punkt:

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

output.dict()

Diesmal gibt es vier Nachrichten. Sehen wir uns die Namensklassennamen und deren Inhalt an:

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

Hier gehen wir! Die dritte Nachricht stammt aus einem Tool -Anruf, bei dem es sich um eine Zusammenfassung einer Wikipedia -Seite zur Photosynthese handelt. Die letzte Nachricht stammt aus dem Chat -Modell, bei dem der Inhalt des Tools beim Erstellen seiner Antwort verwendet wird.

Erstellen wir schnell eine Funktion, um die letzten Schritte zu modularisieren, die wir unternommen haben:

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

3. Verfeinerung der System -Eingabeaufforderung

Aktualisieren wir jetzt unsere Systemaufforderung mit detaillierten Anweisungen, wie sich der Agent verhalten soll:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Lassen Sie uns unseren Agenten mit der neuen System -Eingabeaufforderung erstellen:

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

type(chain)

Fantastisch, basierend auf unserer Nachricht (was sehr lehrreich war :) Der Agent hat das richtige Werkzeug für den Job ausgewählt. Hier ist das generierte Bild:

4. Hinzufügen von Speicher zu Agenten

Im Moment ist unser Agent staatenlos, was bedeutet, dass er sich nicht an frühere Interaktionen erinnert:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Der einfachste Weg, um den Agenten die Chat -Nachrichtenverlauf hinzuzufügen

$ ipython kernel install --user --name=langchain

Wir initialisieren den Speicher mit der Methode .from_conn_string () der SQLiteSaver -Klasse, die eine Datenbankdatei erstellt. Anschließend übergeben wir den Speicher an den Parameter checkPointer von create_react_agent ().

Jetzt müssen wir ein Konfigurationswörterbuch erstellen:

$ touch .env
$ vim .env  # Paste your OPENAI key

Das Wörterbuch definiert eine Thread -ID, um eine Konversation von einem anderen zu unterscheiden, und es wird an die .Invoke () -Methode unseres Agenten übergeben. Aktualisieren wir also unsere Funktion execute (), um dieses Verhalten einzuschließen:

OPENAI_API_KEY='YOUR_KEY_HERE'

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Fragen Sie nun den Agenten nach früheren Fragen:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Wie erwartet gibt der Agent die vorherigen Nachrichten zurück! Jetzt brauchen wir nur eine Chat -Benutzeroberfläche wie die von Chatgpt und haben uns einen benutzerdefinierten Chatbot bekommen.

zukünftige Trends und Entwicklungen

Während des gesamten Artikels haben wir einen Blick darauf geworfen, wohin Langchain in Bezug auf Agenten geht. Bis vor kurzem hatte Langchain hauptsächlich die agentexecutor -Klasse verwendet, wird jedoch langsam durch Langgraph -Agenten ersetzt.

reine Langchain -Agenten sind in Ordnung, um loszulegen, aber sie benötigen mehr Codezeilen, um denselben Agenten zu erstellen als in Langgraph. Nach einem bestimmten Punkt liefert das AgentExecutor-Framework nicht die Flexibilität, die Langgraph für den Aufbau komplexer Multi-Tool-Agenten hat.

deshalb ist jetzt eine gute Zeit, um die Welle zu fahren und direkt mit Langgraph zu beginnen.

Wir empfehlen dringend, auch Langsmith zu verwenden, was zu einem zentralen Bestandteil des Langchain-Ökosystems für LLM-Anwendungen für Bauproduktion geworden ist. Hier sind einige seiner wichtigsten Vorteile:

Debugging: Langsmith bietet detaillierte Spuren der Ausführung Ihres Agenten und erleichtert die Identifizierung und Behebung von Problemen.
Leistungsoptimierung: Mit Langsmith können Sie Token -Nutzung, Latenz und andere Leistungsmetriken analysieren, um die Effizienz Ihres Agenten zu optimieren.
Test und Bewertung: Langsmith erleichtert die Erstellung und Verwaltung von Testdatensätzen und ermöglicht es Ihnen, die Leistung Ihres Agenten rigoros über eine Reihe von Szenarien hinweg zu bewerten.
Überwachung: In Produktionsumgebungen bietet Langsmith Echtzeitüberwachungsfunktionen, sodass Sie die Leistung Ihres Agenten verfolgen und Anomalien schnell erkennen können.

Hier ist, wie Sie mit Langsmith beginnen können:

Melden Sie sich hier für ein kostenloses Konto an.
Umgebungsvariablen festlegen.

exportieren Sie Langchain_tracing_v2 = "true"

exportieren langchain_api_key = "..."

Und du bist gut zu gehen! Wenn Sie mit der Abfragelung von Sprach-/Chat -Modellen beginnen, fängt Langsmith an, verschiedene Metriken zu jedem Lauf zu protokollieren:

Schlussfolgerung

In diesem Artikel haben wir untersucht, was Langchain -Agenten von Ketten unterscheiden und die wichtigen Bausteine ​​unterscheiden, die für die Konstruktion verwendet werden. Wir haben zuerst eingeführt, was Agenten sind und wie sie sich von den traditionelleren Kettenkonstrukten hinsichtlich Flexibilität und Fähigkeiten bei der Entscheidung unterscheiden.

Dann haben wir uns die wichtigsten Komponenten angesehen, die Sie wissen müssen, um einen Agenten zu erstellen: Chat -Modelle, Tools und schnelle Vorlagen. Schließlich haben wir zwei Beispiele durchgeführt, die demonstrierten, wie man einfache und fortschrittliche Agenten baut. Die natürliche Sprachverarbeitung entwickelt sich ständig und Langchain -Agenten stehen im Vordergrund dieser Fortschritte und ebnen den Weg für eine noch intelligentere und vielseitigere Familie von AI.

Hier sind einige verwandte Ressourcen, um Ihre Langchain zu erhöhen:

• Entwickeln von LLM -Anwendungen mit Langchain -Kurs
• Eine Einführung in das schnelle Engineering mit Langchain
• So erstellen Sie LLM -Anwendungen mit Langchain Tutorial
• Erstellen eines GPT -Modells mit Browserfunktionen mit Langchain -Tools
• Langchain gegen llamaindex: ein detaillierter Vergleich

Danke fürs Lesen!

Das obige ist der detaillierte Inhalt vonBau von Langchain -Agenten zur Automatisierung von Aufgaben in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!