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.
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
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.
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.
Eine Wetterapi
rufen Sie die Wetterapi
aufrufen Sie die Wetterapi
aufJede 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:
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:
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.
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.
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.
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
Schauen wir uns nun eine andere Eingabeaufforderung für Chat -Modelle an:
print(output.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!
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
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.
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.
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:
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.
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.')
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:
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
Jetzt müssen wir ein Konfigurationswörterbuch erstellen:
$ touch .env $ vim .env # Paste your OPENAI key
OPENAI_API_KEY='YOUR_KEY_HERE'
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])
There is no definitive answer to this question, as it is subjective and de
zukünftige Trends und Entwicklungen
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:
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:
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:
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!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
