So bauen Sie Chatbots mit LangChain
Dies ist ein Gastbeitrag von Dido Grigorov, einem Deep-Learning-Entwickler und Python-Programmierer mit 17 Jahren Erfahrung auf dem Gebiet.
Chatbots sind heute weit mehr als einfache Frage-und-Antwort-Automaten. Sie nutzen die Leistungsfähigkeit großer Sprachmodelle (large language models, LLM), um den Kontext von Unterhaltungen zu verstehen und menschenähnliche Antworten zu geben. Dies macht sie für Anwendungen im Kundensupport und anderen Arten von virtueller Unterstützung enorm wertvoll.
Das quelloffene Framework LangChain vereinfacht die Erstellung dieser Chatbots, indem es Tools für die nahtlose Modellintegration, Kontextverwaltung und Prompt Engineering bereitstellt.
In diesem Blogartikel erkunden wir, wie LangChain funktioniert und wie Chatbots mit LLMs interagieren. Wir führen Sie außerdem Schritt für Schritt durch die Entwicklung eines kontextsensitiven Chatbots mithilfe von LangChain und GPT-3, der zielgenaue, relevante Antworten gibt.
Was sind LLM-basierte Chatbots?
Auf LLMs basierende Chatbots sind hochmoderne Softwareanwendungen, die über Text- oder Sprachschnittstellen menschenähnliche Unterhaltungen mit Benutzer*innen simulieren. Diese Chatbots nutzen die fortgeschrittenen Fähigkeiten von LLMs, also neuronalen Netzen, die mit riesigen Mengen von Textdaten trainiert wurden und dadurch in der Lage sind, auf ein großes Spektrum von Prompts (Anfragen) menschenähnliche Antworten zu geben.
Unter anderem können LLM-basierte Chatbots bei der Generierung einer Antwort den Kontext der Unterhaltung berücksichtigen. Dies bedeutet, dass sie über mehrere Austauschvorgänge hinweg kohärent bleiben und komplexe Anfragen verarbeiten können, um Ausgaben zu erzeugen, die den Intentionen der Benutzer*innen entsprechen. Außerdem werten diese Chatbots den emotionalen Gehalt der Benutzerinputs aus und passen ihre Antworten an die Gefühlslage ihres Gegenübers an.
Chatbots sind hochgradig anpassungsfähig und personalisiert. Sie lernen daraus, wie Benutzer*innen mit ihnen interagieren und verbessern so ihre Antworten, indem sie diese an individuelle Vorlieben und Bedürfnisse anpassen.
Was ist LangChain?
LangChain ist ein quelloffenes Framework, das für die Erstellung von Anwendungen entwickelt wurde, die große Sprachmodelle (LLMs) verwenden. Es verfügt über Tools und Abstraktionen, um die aus diesen Modellen gewonnenen Informationen besser zu personalisieren und dabei Korrektheit und Relevanz zu wahren.
Ein gängiger Begriff in der Literatur über LLMs ist „Promptkette“. Eine Promptkette bezieht sich auf eine Abfolge von Prompts oder Anweisungen, die im Kontext von künstlicher Intelligenz und maschinellem Lernen verwendet werden, um das KI-Modell in einem mehrstufigen Prozess zum Generieren von genaueren, detaillierteren oder verbesserten Ergebnissen anzuleiten. Diese Methode kann für verschiedene Aufgaben eingesetzt werden, etwa für das Schreiben, das Lösen von Problemen oder die Generierung von Code.
Entwickler*innen können mit LangChain neue Promptketten erstellen – das ist eine der größten Stärken des Frameworks. Sie können sogar bestehende Promptvorlagen verändern, ohne das Modell bei Verwendung neuer Datensammlungen erneut trainieren zu müssen.
Wie funktioniert LangChain?
LangChain ist ein Framework, das die Entwicklung von Anwendungen vereinfachen soll, die Sprachmodelle verwenden. Es bietet eine Reihe von Tools, die Entwickler*innen bei der effizienten Entwicklung und Verwaltung von Anwendungen helfen, die auf linguistische Datenverarbeitung (NLP) und große Sprachmodelle zurückgreifen. Mit LangChain können Entwickler*innen Sprachmodelle flexibel an spezifische Geschäftskontexte anpassen, indem sie die Schritte definieren, die zum Erreichen des gewünschten Ergebnisses erforderlich sind (dies kann ein Chatbot, eine Aufgabenautomatisierung, ein virtueller Assistent, Kundensupport und vieles mehr sein).
Im Folgenden finden Sie einen groben Überblick über die Funktionsweise von LangChain.
Modellintegration
LangChain unterstützt verschiedene Sprachmodelle, unter anderem von OpenAI, Hugging Face, Cohere, Anyscale, Azure Models, Databricks, Ollama, Llama, GPT4All, Spacy, Pinecone, AWS Bedrock und MistralAI. Entwickler*innen können unkompliziert zwischen Modellen wechseln oder mehrere Modelle in einer Anwendung verwenden. Sie können maßgeschneiderte Lösungen für die Modellintegration erstellen, um spezielle Fähigkeiten zu nutzen, die auf ihre konkreten Anwendungen zugeschnitten sind.
Ketten
Das Kernkonzept von LangChain sind Ketten, die unterschiedliche KI-Komponenten zur Erzeugung von kontextsensitiven Antworten zusammenbringen. Eine Kette repräsentiert eine Reihe von automatisierten Aktionen zwischen einer Benutzereingabe und der endgültigen Modellausgabe. LangChain stellt zwei Arten von Ketten bereit:
- Sequenzielle Ketten: Mit diesen Ketten kann die Ausgabe eines Modells oder einer Funktion als Eingabe für ein anderes Modell bzw. eine andere Funktion verwendet werden. Besonders hilfreich ist dies bei der Erstellung von mehrstufigen Prozessen, die voneinander abhängen.
- Parallele Ketten: Diese ermöglichen die gleichzeitige Ausführung mehrerer Aufgaben, deren Ergebnisse am Ende zusammengeführt werden. Damit eignen sie sich perfekt für Aufgaben, die in voneinander vollständig unabhängige Teilaufgaben unterteilt werden können.
Arbeitsspeicher
LangChain erleichtert das Speichern und Abrufen von Informationen über mehrere Interaktionen hinweg. Besonders wichtig ist dies, wenn – wie bei Chatbots oder interaktiven Agents – der Kontext erhalten bleiben soll. Es werden zwei Arten von Speicher bereitgestellt:
- Kurzzeitspeicher – Ermöglicht das Speichern der letzten Sitzungen.
- Langzeitspeicher – Ermöglicht das Speichern von Informationen aus früheren Sitzungen, um die Fähigkeit des Systems zu verbessern, sich an vergangene Chats und Benutzerpräferenzen zu erinnern.
Tools und Hilfsmittel
LangChain stellt zahlreiche Tools bereit, aber die am häufigsten verwendeten sind Prompt Engineering, Data Loader und Evaluatoren. Im Hinblick auf Prompt Engineering enthält LangChain Hilfsmittel zur Entwicklung guter Prompts, die sehr wichtig sind, um die besten Antworten aus Sprachmodellen herauszuholen.
Wenn Sie Dateien im CSV-, PDF- oder anderen Formaten laden möchten, helfen Ihnen Data Loader dabei, unterschiedliche Datentypen zu laden und durch eine Vorverarbeitung für Modellinteraktionen nutzbar zu machen.
Die Auswertung oder Evaluierung ist ein wesentlicher Bestandteil der Arbeit mit ML-Modellen und großen Sprachmodellen. Aus diesem Grund stellt LangChain Evaluatoren bereit – Werkzeuge zum Testen von Sprachmodellen und -ketten, um sicherzustellen, dass die generierten Ergebnisse die benötigten Kriterien erfüllen. Zum Beispiel:
Kriterien für Datensammlungen:
- Manuell kuratierte Beispiele: Beginnen Sie mit hochwertigen, vielfältigen Inputs.
- Historische Protokolle: Nutzen Sie echte Benutzerdaten und -feedback.
- Synthetische Daten: Hierbei werden aus den Ursprungsdaten weitere Beispiele generiert.
Evaluierungsarten:
- Menschlich: Bewertung und Feedback werden manuell vorgenommen.
- Heuristisch: Regelbasierte Funktionen, sowohl referenzfrei als auch referenzbasiert.
- LLM-basiert: LLMs bewerten die Outputs anhand von einprogrammierten Kriterien.
- Paarweise: Zwei Outputs werden verglichen, um den besseren auszuwählen.
Anwendungsevaluierung:
- Unit-Tests: Schnelle, auf Heuristiken basierende Prüfungen.
- Regressionstests: Messen der Leistung im Zeitverlauf.
- Backtesting: Testen neuer Versionen mit vorhandenen Produktionsdaten.
- Online-Evaluierung: Echtzeit-Evaluierung, oft in Bezug auf Schutzmaßnahmen (Guardrails) und Klassifizierungen.
Agents
LangChain-Agents sind im Wesentlichen autonome Einheiten, die LLMs nutzen, um auf der Grundlage von natürlichsprachlichen Inputs mit Benutzer*innen zu interagieren, Aufgaben auszuführen und Entscheidungen zu treffen.
Aktionsorientierte Agents verwenden Sprachmodelle, um für vorgegebene Aufgaben das optimale Vorgehen zu ermitteln. Interaktive Agents oder interaktive Anwendungen wie Chatbots wiederum nutzen diese Agents, die bei der Beantwortung von Anfragen auch Benutzereingaben und gespeicherte Daten berücksichtigen.
Wie verwenden Chatbots LLMs?
Die den Chatbots zugrunde liegenden LLMs verwenden Natural Language Understanding (NLU, Verständnis natürlicher Sprache) und Natural Language Generation (NLG, Erzeugung natürlicher Sprache), ermöglicht durch das vorherige Training von Modellen mit umfangreichen Textdaten.
Verständnis natürlicher Sprache (NLU)
- Kontextbezogenheit: LLMs können Feinheiten und Anspielungen in einer Unterhaltung verstehen und das Gespräch von einer Interaktion zur nächsten verfolgen. Dadurch können Chatbots logische und zum Kontext passende Antworten generieren.
- Intentionserkennung: Diese Modelle sollten in der Lage sein, die Intention der Benutzer*innen anhand ihrer Anfragen zu erkennen, unabhängig davon, ob sie eine sehr spezifische oder eher allgemeine Sprache verwenden. Sie können erkennen, was die Benutzer*innen erreichen möchten und den besten Weg zum Erreichen dieses Ziels bestimmen.
- Sentimentanalyse: Chatbots können die Emotionen ihres Gegenübers durch den verwendeten Sprachton erkennen und sich daran anpassen, was die Interaktionsbereitschaft der Benutzerinnen erhöht.
Erzeugung natürlicher Sprache (NLG)
- Antwortgenerierung: Wenn an LLMs Fragen gestellt werden, geben sie Antworten, die sowohl grammatikalisch als auch in Bezug auf den Kontext korrekt sind. Das liegt daran, dass die Antworten, die diese Modelle erzeugen, die menschliche Kommunikation nachahmen. Ermöglicht wird dies durch das Trainieren der Modelle mit riesigen Mengen an natürlichsprachlichen Textdaten.
- Kreativität und Flexibilität: Neben einfachen Antworten können LLM-basierte Chatbots auch eine Geschichte erzählen, ein Gedicht verfassen oder eine detaillierte Beschreibung eines bestimmten technischen Problems geben – sie sind also sehr flexibel in Bezug auf das bereitgestellte Material.
Personalisierung und Anpassungsfähigkeit
- Lernen aus Interaktionen: Chatbots personalisieren ihre Interaktionen, da sie die Fähigkeit haben, aus dem Verhalten und den Entscheidungen der Benutzer*innen zu lernen. Man kann sagen, dass Chatbots ständig dazulernen und dadurch bei der Beantwortung von Fragen effektiver und präziser werden.
- Anpassung an unterschiedliche Gebiete: LLMs können auf bestimmte Bereiche oder Spezialgebiete abgestimmt werden. Auf diese Weise können Chatbots als Fachexperten etwa im Kundenbeziehungsmanagement, im technischen Support oder im Gesundheitswesen auftreten.
LLMs können Text in mehreren Sprachen verstehen und generieren, was sie für den Einsatz in verschiedenen linguistischen Kontexten prädestiniert.
Erstellen eines eigenen Chatbots mit LangChain in fünf Schritten
Ziel dieses Projekts ist die Entwicklung eines Chatbots, der GPT-3 nutzt, um in Dokumenten Antworten auf Fragen zu finden. Als Erstes laden wir Inhalte aus Online-Artikeln herunter, zerlegen sie in kleine Teile, berechnen deren Embeddings und speichern sie in Deep Lake. Anschließend verwenden wir eine Benutzerabfrage, um die relevantesten Teile aus Deep Lake abzurufen und diese in einen Prompt zu integrieren, um die endgültige Antwort vom LLM generieren zu lassen.
Es ist wichtig zu wissen, dass die Verwendung von LLMs das Risiko birgt, falsche Informationen – sogenannte Halluzinationen – zu generieren. Auch wenn dies in vielen Kundensupport-Szenarien inakzeptabel ist, kann der Chatbot dennoch wertvoll sein, um Mitarbeitende beim Verfassen von Antworten zu unterstützen, die sie dann überprüfen, bevor sie sie an Benutzer*innen weitersenden.
Als Nächstes sehen wir uns an, wie Unterhaltungen mit GPT-3 verwaltet werden können und zeigen die Effektivität dieses Workflows anhand von Beispielen.
Schritt 1: Projekterstellung, Voraussetzungen und Installation der Bibliotheken
Erstellen Sie als Erstes Ihr PyCharm-Projekt für den Chatbot. Öffnen Sie PyCharm und klicken Sie auf „New project“. Geben Sie dann Ihrem Projekt einen Namen.
Nachdem Sie das Projekt eingerichtet haben, generieren Sie Ihren ‘OPENAI_API_KEY‘ auf der Website der OpenAI-API-Plattform. Dazu müssen Sie sich einloggen (bzw. sich auf der OpenAI-Website zu diesem Zweck registrieren). Öffnen Sie dazu den Bereich „API Keys“ im linken Navigationsmenü und klicken Sie dann auf die Schaltfläche „+Create new secret key“. Denken Sie daran, Ihren Schlüssel zu kopieren.
Danach müssen Sie Ihren ‘ACTIVELOOP_TOKEN‘ beziehen. Hierzu registrieren Sie sich auf der Activeloop-Website. Sobald Sie eingeloggt sind, klicken Sie einfach auf die Schaltfläche „Create API Token“, um zur Seite für die Erstellung des Tokens weitergeleitet zu werden. Kopieren Sie auch diesen Token.
Wenn Sie sowohl den Token als auch den Schlüssel erhalten haben, öffnen Sie Ihre Konfigurationseinstellungen in PyCharm, indem Sie auf die Schaltfläche mit den drei Punkten neben den Schaltflächen Ausführen und Debuggen klicken, und wählen Sie „Edit“. Sie sollten das folgende Fenster sehen:
Suchen Sie nun das Feld „Environment variables“ und das Symbol rechts neben dem Feld. Wenn Sie darauf klicken, erscheint das folgende Fenster:
Klicken Sie nun auf die Schaltfläche + und geben Sie Ihre Umgebungsvariablen ein – achten Sie dabei auf die genaue Schreibweise. Wie oben zu sehen sollten die Variablen wie folgt lauten: ‘OPENAI_API_KEY‘ und ‘ACTIVELOOP_TOKEN‘. Wenn Sie fertig sind, klicken Sie im ersten Fenster auf „OK“ und im zweiten Fenster auf „Apply“ und „OK“.
Das ist ein großer Vorteil von PyCharm und ich mag es sehr, weil es die Umgebungsvariablen automatisch für uns handhabt, ohne dass wir zusätzliche Aufrufe verwenden müssen. So können wir uns auf den kreativen Teil des Codes konzentrieren.
Hinweis: Activeloop ist ein Technologieunternehmen, das sich der Entwicklung von Dateninfrastrukturen und Tools für maschinelles Lernen und künstliche Intelligenz widmet. Ziel des Unternehmens ist es, die Verwaltung, Speicherung und Verarbeitung großer Datenmengen zu vereinfachen, insbesondere für Deep Learning und andere KI-Anwendungen.
Deep Lake ist das Hauptprodukt von Activeloop. Für die Speicherung, das Management und den Zugriff auf Daten stellt es effiziente Funktionen bereit. Diese sind für große Datensammlungen optimiert, die häufig in KI-Anwendungen verwendet werden.
Erforderliche Bibliotheken installieren
Wir verwenden die Klasse ‘SeleniumURLLoader‘ von LangChain, die auf die Python-Bibliotheken ‘unstructured‘ und ‘selenium‘ zurückgreift. Installieren Sie diese mit pip. Es ist empfehlenswert, die neueste Version zu installieren, obwohl der Code speziell mit Version 0.7.7 getestet wurde.
Geben Sie dazu den folgenden Befehl in Ihrem PyCharm-Terminal ein:
pip install unstructured selenium
Jetzt müssen wir noch langchain, deeplake und openai installieren. Verwenden Sie dazu diesen Befehl in Ihrem Terminal (dasselbe Fenster, das Sie auch für Selenium verwendet haben) und warten Sie ein wenig, bis alles erfolgreich installiert wurde:
pip install langchain==0.0.208 deeplake openai==0.27.8 psutil tiktoken
Um sicherzustellen, dass alle Bibliotheken korrekt installiert sind, geben Sie einfach die folgenden Zeilen ein, die für unsere Chatbot-App benötigt werden, und klicken Sie auf die Run-Schaltfläche:
from langchain.embeddings.openai import OpenAIEmbeddings from langchain.vectorstores import DeepLake from langchain.text_splitter import CharacterTextSplitter from langchain import OpenAI from langchain.document_loaders import SeleniumURLLoader from langchain import PromptTemplate
Alternativ können Sie Ihre Bibliotheken auch in den Einstellungen von PyCharm installieren. Öffnen Sie die Einstellungen und gehen Sie zum Abschnitt Project -> Python Interpreter. Suchen Sie dann über die Schaltfläche + nach Ihrem Paket und klicken Sie auf „Install Package“. Sobald der Vorgang abgeschlossen ist, schließen Sie das Fenster und klicken im nächsten Fenster auf „Apply“ und dann auf „OK“.
Schritt 2: Inhalte aufteilen und Embeddings berechnen
Wie bereits erwähnt soll unser Chatbot mit Inhalten aus Online-Artikeln „kommunizieren“. Aus diesem Grund habe ich Digitaltrends.com als Datenquelle gewählt und zunächst 8 Artikel ausgewählt. Alle werden in eine Python-Liste aufgenommen und der Variablen „articles“ zugewiesen.
articles = ['https://www.digitaltrends.com/computing/claude-sonnet-vs-gpt-4o-comparison/',
'https://www.digitaltrends.com/computing/apple-intelligence-proves-that-macbooks-need-something-more/',
'https://www.digitaltrends.com/computing/how-to-use-openai-chatgpt-text-generation-chatbot/',
'https://www.digitaltrends.com/computing/character-ai-how-to-use/',
'https://www.digitaltrends.com/computing/how-to-upload-pdf-to-chatgpt/']
Wir laden die Dokumente von den angegebenen URLs herunter und teilen sie mit ‘CharacterTextSplitter‘ in Chunks von der Größe 1000 ohne Überlappung:
# Use the selenium to load the documents loader = SeleniumURLLoader(urls=articles) docs_not_splitted = loader.load() # Split the documents into smaller chunks text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) docs = text_splitter.split_documents(docs_not_splitted)
Wenn Sie den bisherigen Code ausführen, sollten Sie den folgenden Output erhalten:
[Document(page_content="techcrunchnntechcrunchnnWe, TechCrunch, are part of the Yahoo family of brandsThe sites and apps that we own and operate, including Yahoo and AOL, and our digital advertising service, Yahoo Advertising.Yahoo family of brands.nn When you use our sites and apps, we use nnCookiesCookies (including similar technologies such as web storage) allow the operators of websites and apps to store and read information from your device. Learn more in our cookie policy.cookies to:nnprovide our sites and apps to younnauthenticate users, apply security measures, and prevent spam and abuse, andnnmeasure your use of our sites and appsnn If you click '", metadata={'source': ……………]
Als Nächstes generieren wir die Embeddings mit OpenAIEmbeddings und speichern sie in einem Deep Lake-Vektorspeicher in der Cloud. In einer Produktionsumgebung könnten wir im Idealfall eine komplette Website oder das Material für einen ganzen Kurs in eine Deep Lake Datensammlung hochladen, um eine Suche in Tausenden oder sogar Millionen von Dokumenten zu ermöglichen.
Durch die Nutzung einer serverlosen Deep-Lake-Datensammlung in der Cloud können Anwendungen von verschiedenen Orten aus reibungslos auf eine zentralisierte Datensammlung zugreifen, ohne einen Vektorspeicher auf einem dedizierten System einzurichten.
Warum brauchen wir Embeddings und in Chunks geteilte Dokumente?
Bei der Entwicklung von Chatbots mit LangChain sind Embeddings und das Aufteilen von Dokumenten in Chunks unerlässlich, und zwar aus mehreren Gründen, die mit der Effizienz, der Korrektheit und der Performance des Chatbots zusammenhängen.
Embeddings sind Vektordarstellungen, die die semantische Bedeutung von Textinhalten (Wörtern, Sätzen, Absätzen oder Dokumenten) erfassen. Sie stellen den Kontext und die Bedeutung der Wörter in numerischer Form dar. Dies ermöglicht es dem Chatbot, Sprache zu verstehen und kontextbasierte Antworten zu generieren, indem er Nuancen, Synonyme und Beziehungen zwischen Wörtern erfasst.
Der Chatbot kann außerdem die relevantesten Antworten oder Informationen in einer Wissensdatenbank identifizieren und abrufen, denn die Embeddings ermöglichen es, Benutzeranfragen den semantisch relevantesten Informationsteilen zuzuordnen, selbst wenn der Wortlaut unterschiedlich ist.
Beim Chunking wiederum geht es um die Aufteilung großer Dokumente in kleinere, überschaubare Stücke (Chunks). Kleinere Chunks lassen sich schneller verarbeiten und analysieren als große, monolithische Dokumente. Dies steigert die Reaktionsschnelligkeit des Chatbots.
Das Chunking von Dokumenten fördert auch die Relevanz des Outputs, denn wenn Benutzer*innen eine Frage stellen, findet sich die Antwort oft nur in einem bestimmten Teil eines Dokuments. Durch Chunking kann das System die relevanten Abschnitte eingrenzen und abrufen, und der Chatbot kann präzisere und korrektere Antworten geben.
Kehren wir nun zu unserer Anwendung zurück und aktualisieren wir den folgenden Code, indem wir Ihre Activeloop-Organisations-ID einfügen. Beachten Sie, dass Ihre Organisations-ID standardmäßig Ihrem Benutzernamen entspricht.
# TODO: use your organization id here. (by default, org id is your username)
my_activeloop_org_id = "didogrigorov"
my_activeloop_dataset_name = "jetbrains_article_dataset"
dataset_path = f"hub://{my_activeloop_org_id}/{my_activeloop_dataset_name}"
db = DeepLake(dataset_path=dataset_path, embedding_function=embeddings)
# add documents to our Deep Lake dataset
db.add_documents(docs)
Eine weitere großartige Funktion von PyCharm ist die Möglichkeit, TODO-Anmerkungen direkt in Python-Kommentaren einzufügen. Wenn Sie TODO in Großbuchstaben eingeben, wird Ihre Notiz in einem PyCharm-Bereich angezeigt, der Ihnen einen Überblick über alle Todo-Einträge bietet:
# TODO: use your organization id here. (by default, org id is your username)
Sie können sie anklicken und PyCharm zeigt Ihnen direkt, wo sie sich in Ihrem Code befinden. Ich finde das sehr praktisch für die Entwicklung und nutze es ständig:
Wenn Sie den bisherigen Code ausführen, sollten Sie die folgende Ausgabe sehen, wenn alles normal funktioniert:
Um die Chunks zu finden, die einer bestimmten Abfrage am ähnlichsten sind, können wir die Methode similarity_search des Deep-Lake-Vektorspeichers verwenden:
# Check the top relevant documents to a specific query query = "how to check disk usage in linux?" docs = db.similarity_search(query) print(docs[0].page_content)
Schritt 3: Prompt für GPT-3 erstellen
Wir erstellen eine Promptvorlage, die Rollen-Prompting, relevante Daten aus der Wissensdatenbank sowie die Benutzerfrage enthält. Diese Vorlage etabliert die Persönlichkeit des Chatbots als herausragende Supportkraft. Sie hat zwei Eingabevariablen: chunks_formatted enthält die vorformatierten Artikelauszüge, und query enthält die Kundenfrage. Das Ziel ist es, eine präzise Antwort ausschließlich auf Grundlage der vorgegebenen Chunks zu erstellen und dabei jegliche erfundenen oder nicht korrekten Informationen zu vermeiden.
Schritt 4: Chatbot-Funktionalität aufbauen
Um eine Antwort zu generieren, rufen wir zunächst die obersten k (z. B. 3) Chunks ab, die der Benutzeranfrage am ähnlichsten sind. Diese Chunks werden dann zu einem Prompt formatiert, der mit einer Temperatureinstellung von 0 an das GPT-3-Modell gesendet wird.
# user question query = "How to check disk usage in linux?" # retrieve relevant chunks docs = db.similarity_search(query) retrieved_chunks = [doc.page_content for doc in docs] # format the prompt chunks_formatted = "nn".join(retrieved_chunks) prompt_formatted = prompt.format(chunks_formatted=chunks_formatted, query=query) # generate answer llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0) answer = llm(prompt_formatted) print(answer)
Wenn alles funktioniert, sollte Ihre Ausgabe so aussehen:
To upload a PDF to ChatGPT, first log into the website and click the paperclip icon next to the text input field. Wählen Sie dann die PDF-Datei von Ihrer lokalen Festplatte, Google Drive oder Microsoft OneDrive aus. Wenn Sie die Datei angehängt haben, geben Sie Ihre Anfrage oder Frage in das Eingabefeld ein und klicken Sie auf die Schaltfläche „Hochladen“. Geben Sie dem System Zeit, die PDF-Datei zu analysieren und Ihnen eine Antwort zu geben.
Schritt 5: Gesprächsverlauf erstellen
# Create conversational memory
memory = ConversationBufferMemory(memory_key="chat_history", input_key="input")
# Define a prompt template that includes memory
template = """You are an exceptional customer support chatbot that gently answers questions.
{chat_history}
You know the following context information.
{chunks_formatted}
Answer the following question from a customer. Use only information from the previous context information. Do not invent stuff.
Question: {input}
Answer:"""
prompt = PromptTemplate(
input_variables=["chat_history", "chunks_formatted", "input"],
template=template,
)
# Initialize the OpenAI model
llm = OpenAI(openai_api_key="YOUR API KEY", model="gpt-3.5-turbo-instruct", temperature=0)
# Create the LLMChain with memory
chain = LLMChain(
llm=llm,
prompt=prompt,
memory=memory
)
# User query
query = "What was the 5th point about on the question how to remove spotify account?"
# Retrieve relevant chunks
docs = db.similarity_search(query)
retrieved_chunks = [doc.page_content for doc in docs]
# Format the chunks for the prompt
chunks_formatted = "nn".join(retrieved_chunks)
# Prepare the input for the chain
input_data = {
"input": query,
"chunks_formatted": chunks_formatted,
"chat_history": memory.buffer
}
# Simulate a conversation
response = chain.predict(**input_data)
print(response)
Gehen wir den Code im Einzelnen durch.
Zunächst legen wir mit ‘ConversationBufferMemory‘ einen Konversationsspeicher an. So kann sich unser Chatbot den Chatverlauf merken und mit ‘input_key="input"‘ den Benutzerinput verwalten.
Als Nächstes erstellen wir eine Promptvorlage. Diese Vorlage ist wie ein Skript für den Chatbot und enthält Abschnitte für den Chatverlauf, die gesammelten Informationsteile und den aktuellen Benutzerinput (Frage). Durch diese Struktur weiß der Chatbot genau, welchen Kontext er zu berücksichtigen hat und welche Frage er beantworten muss.
Danach initialisieren wir unsere Sprachmodellkette mit ‘LLMChain‘. Wir können uns dies als einen Zusammenbau von Einzelteilen vorstellen: Wir nehmen unsere Promptvorlage, das Sprachmodell und den im Vorfeld eingerichteten Speicher und kombinieren sie zu einem Workflow.
Wenn es soweit ist und wir eine Benutzerfrage bearbeiten müssen, bereiten wir den Input vor. Dabei wird ein Dictionary erstellt, das die Benutzerfrage (‘input‘) und die entsprechenden Informationsteile (‘chunks_formatted‘) enthält. Durch diese Einrichtung stellen wir sicher, dass der Chatbot über alle Informationen verfügt, die er für eine fundierte Antwort benötigt.
Schließlich generieren wir die Antwort. Wir rufen die Methode ‘chain.predict‘ mit unseren vorbereiteten Input-Daten auf. Die Methode verarbeitet diese Eingaben gemäß dem von uns vorgegebenen Workflow und gibt uns die Antwort des Chatbots zurück, die wir dann anzeigen.
Durch diesen Ansatz kann unser Chatbot eine flüssige, informierte Unterhaltung führen, sich an vergangene Interaktionen erinnern und unter Berücksichtigung des Kontexts relevante Antworten bereitstellen.
Ein weiterer meiner Lieblingstricks in PyCharm, der mir bei der Erstellung dieser Funktionalität sehr geholfen hat, war die Möglichkeit, mit gedrückter Strg-Taste eine Methode anzuklicken.
Fazit
GPT-3 eignet sich hervorragend für die Erstellung von Chatbots, die spezifische Fragen auf Grundlage der im Prompt bereitgestellten Kontextinformationen beantworten. Sicherzustellen, dass das Modell seine Antworten ausschließlich auf der Grundlage dieses Kontexts generiert, kann allerdings schwierig sein, denn das Modell halluziniert gerne (d. h. es erfindet neue, möglicherweise falsche Informationen). Die Auswirkungen solcher Fehlinformationen sind je nach Anwendungsfall unterschiedlich.
Abschließend können wir festhalten, dass wir mit LangChain unter Verwendung der bereitgestellten Codeabschnitte und Strategien ein kontextsensitives Frage-Antwort-System entwickelt haben. Dabei haben wir Dokumente in Chunks aufgeteilt, ihre Embeddings berechnet, ein Abfragesystem zum Auffinden ähnlicher Chunks implementiert, einen Prompt für GPT-3 erstellt und das GPT-3-Modell für die Textgenerierung verwendet. Dieser Ansatz zeigt das Potenzial, mit GPT-3 leistungsstarke und kontextbasierte Chatbots zu erstellen. Gleichzeitig wird erkennbar, wie wichtig es ist, auf die Gefahr der Generierung von Falschinformationen zu achten.
Zum Autor
Autorin des ursprünglichen Blogposts
Subscribe to PyCharm Blog updates
