5. Unterrichtsblock

Kursinhalte

• LangChain
• Agenten & Chains
• Tutorial

LangChain

LangChain ist ein quelloffenes Framework, um LLM-basierte Applikationen zu entwickeln.

Mit Hilfe dieses Rahmenwerks können Entwickler beispielsweise:

• Chatbots oder persönliche Assistenten erstellen,
• Dokumente oder strukturierte Daten zusammenfassen, respektive analysieren,
• Code schreiben und besser verstehen, oder
• mit APIs interagieren.

Derzeit gibt es zwei Versionen von LangChain – eine für Python und eine für TypeScript/JavaScript.

Wie LangChain funktioniert

LangChain ermöglicht es Sprachmodellen, sich mit Datenquellen zu verbinden und mit ihrer Umgebung zu interagieren.

• LangChain-Komponenten sind modulare Abstraktionen und Sammlungen von Implementierungen dieser Abstraktionen.
• Off-the-Shelf-Ketten (-Chains) sind strukturierte Zusammenstellungen von Komponenten, um bestimmte übergeordnete Tasks zu erfüllen.
• Man können Komponenten verwenden, um bestehende Ketten anzupassen und um neue Chains zu erstellen.

In diesem Zusammenhang gibt es außerdem zwei Arten von Sprachmodellen:

• Bei Large Language Models bestehen Input und Output jeweils aus einer Zeichenkette.
• Bei Chat-Modellen dient eine Liste von Nachrichten als Input und eine Chat-Nachricht als Output. Letztere enthalten wiederum zwei Komponenten – Inhalt und Rolle (gibt Auskunft über die Quelle des Inhalts).

Im Allgemeinen verwenden Sprachmodelle Prompt-Templates für ihre Inputs. Damit lässt sich definieren, welche Aufgabe ein Sprach- oder Chatmodell übernehmen soll – etwa die des Assistenten, der Englisch in Französisch übersetzt. Die Templates lassen sich darüber hinaus auch auf viele verschiedene Inhaltsinstanzen anwenden – etwa einer Liste von Sätzen, die übersetzt werden sollen.

LangChain besteht aus sechs Modulen:

• Model I/O (Schnittstelle zu Sprachmodellen),
• Data Connection (Schnittstelle zu anwendungsspezifischen Daten),
• Chains (konstruieren Call-Sequenzen),
• Agents (ermöglichen den Chains, die zu verwendenden Tools anhand von High-Level-Direktiven auszuwählen),
• Memory (bewahrt den Anwendungsstatus zwischen den „Chain Runs“) und
• Callbacks (protokollieren und streamen die Zwischenschritte einer jeden Chain).

Debugging mit LangSmith

Geht es darum, die mit LangChain generierten Applikationen vom Prototypenstatus in die Produktion zu überführen, bietet LangSmith Unterstützung.

LangChain-Anwendungsfälle

Zu den Anwendungsfällen für LangChain gehören:

• Q&A-Generierung aus Dokumenten,
• die Analyse strukturierter Daten,
• API-Interaktionen,
• Code Verständnis,
• Agenten-Simulationen,
• autonome Agenten,
• Chatbots,
• Code-Generierung,
• Datenextraktion,
• Graphdatenanalyse,
• multimodale Outputs,
• Selbstüberprüfung,
• Zusammenfassung und
• Tagging.

LangChain-Integrationen

In Sachen Integrationen zeigt sich LangChain vielfältig und unterstützt zahlreiche:

• Callbacks,
• Chat-Modelle,
• Document Loader,
• Document Transformer,
• LLMs,
• Memory,
• Retriever,
• Text-Embedding-Modelle,
• Agents & Toolkits,
• Tools und
• Vector Stores.

LangChain fungiert dabei im Wesentlichen als neutraler Knotenpunkt für all diese Fähigkeiten.

LangChain installieren

Um LangChain für Python zu installieren, verwendet nman pip.

Die grundlegende, minimale Installation starten man mit folgendem Befehl:

Nicht darin enthalten die Module für Modell-Provider, Data Stores und andere Integrationen. Um LangChain gemeinsam mit den gängigen Sprachmodellen zu installieren, verwenden man:

Um LangChain inklusive sämtlicher Integrationen zu installieren, lautet der Befehl:

Alle Tutorials zu LangChain

LangChain Tutorials: https://python.langchain.com/docs/additional_resources/tutorials

Aufgabe

Baue einen Agenten, der prüft, ob Gerhard Schröder mit Otto Bismarck sprechen kann.
Erlaubte Hilfsmittel: https://chat.langchain.com/

Dateien öffnen

Assume we have the following file, located in the same folder as Python:

demofile.txt

Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck!

To open the file, use the built-in open() function.

The open() function returns a file object, which has a read() method for reading the content of the file:

ExampleGet your own Python Server

f = open(„demofile.txt“, „r“)
print(f.read())

Run Example »

If the file is located in a different location, you will have to specify the file path, like this:

Example

Open a file on a different location:

f = open(„D:\\myfiles\welcome.txt“, „r“)
print(f.read())

Run Example »

Read Only Parts of the File

By default the read() method returns the whole text, but you can also specify how many characters you want to return:

Example

Return the 5 first characters of the file:

f = open(„demofile.txt“, „r“)
print(f.read(5))

Run Example »

ADVERTISEMENT

ADVERTISEMENT

ADVERTISEMENT

Read Lines

You can return one line by using the readline() method:

Example

Read one line of the file:

f = open(„demofile.txt“, „r“)
print(f.readline())

Run Example »

By calling readline() two times, you can read the two first lines:

Example

Read two lines of the file:

f = open(„demofile.txt“, „r“)
print(f.readline())
print(f.readline())

Run Example »

By looping through the lines of the file, you can read the whole file, line by line:

Example

Loop through the file line by line:

f = open(„demofile.txt“, „r“)
for x in f:
print(x)

Run Example »

Close Files

It is a good practice to always close the file when you are done with it.

Example

Close the file when you are finish with it:

f = open(„demofile.txt“, „r“)
print(f.readline())
f.close()

Run Example »

Note: You should always close your files, in some cases, due to buffering, changes made to a file may not show until you close the file.

Aufgabe

Baue eine Eingabe für einen Taschenrechner, die prüft, ob die eingegebene Zahl eine Ganzzahl ist.

LangChain ist ein Framework zur Entwicklung von Anwendungen, die auf Sprachmodellen basieren. In diesem LangChain-Crashkurs lernen Sie, wie Sie Anwendungen erstellen, die auf großen Sprachmodellen basieren. Wir gehen alle wichtigen Funktionen dieses Frameworks durch.

• GitHub-Repo
• Offizielle Dokumente

Überblick: ¶

• Installation
• LLMs
• Eingabeaufforderungsvorlagen
• Ketten
• Agenten und Tools
• Erinnerung
• Dokumentenlader
• Indizes

Probieren Sie den gesamten Code in diesem Google Colab aus .

Installation ¶

pip install langchain

LLMs ¶

LangChain bietet eine generische Schnittstelle für viele verschiedene LLMs. Die meisten von ihnen funktionieren über ihre API, Sie können aber auch lokale Modelle ausführen.

Alle LLM-Anbieter anzeigen .pip install openai import os os.environ["OPENAI_API_KEY"] ="YOUR_OPENAI_TOKEN" from langchain.llms import OpenAI llm = OpenAI(temperature=0.9) # model_name="text-davinci-003" text = "What would be a good company name for a company that makes colorful socks?" print(llm(text)) pip install huggingface_hub os.environ["HUGGINGFACEHUB_API_TOKEN"] = "YOUR_HF_TOKEN" from langchain import HuggingFaceHub # https://huggingface.co/google/flan-t5-xl llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature":0, "max_length":64}) llm("translate English to German: How old are you?")

Eingabeaufforderungsvorlagen

LangChain ermöglicht eine zeitnahe Verwaltung und Optimierung.

Wenn Sie ein LLM in einer Anwendung verwenden, senden Sie normalerweise keine Benutzereingaben direkt an das LLM. Stattdessen müssen Sie die Benutzereingaben nutzen, eine Eingabeaufforderung erstellen und diese erst dann an das LLM senden.llm("Can Barack Obama have a conversation with George Washington?")

Eine bessere Eingabeaufforderung ist diese:prompt = """Question: Can Barack Obama have a conversation with George Washington? Let's think step by step. Answer: """ llm(prompt)

Dies kann erreicht werden mit PromptTemplates:from langchain import PromptTemplate template = """Question: {question} Let's think step by step. Answer: """ prompt = PromptTemplate(template=template, input_variables=["question"]) prompt.format(question="Can Barack Obama have a conversation with George Washington?")

Ketten

Kombinieren Sie LLMs und Eingabeaufforderungen in mehrstufigen Workflows.from langchain import LLMChain llm_chain = LLMChain(prompt=prompt, llm=llm) question = "Can Barack Obama have a conversation with George Washington?" print(llm_chain.run(question))

Agenten und Tools ¶

Agenten beinhalten, dass ein LLM Entscheidungen darüber trifft, welche Maßnahmen ergriffen werden sollen, diese Maßnahme übernimmt, eine Beobachtung sieht und diese wiederholt, bis sie erledigt ist.

Bei richtiger Anwendung können Wirkstoffe äußerst wirksam sein. Um Agenten zu laden, sollten Sie die folgenden Konzepte verstehen:

• Werkzeug: Eine Funktion, die eine bestimmte Aufgabe ausführt. Dies können Dinge sein wie: Google-Suche, Datenbanksuche, Python REPL und andere Ketten. Siehe verfügbare Tools .
• LLM: Das Sprachmodell, das den Agenten antreibt.
• Agent: Der zu verwendende Agent. Siehe auch Agententypen .

from langchain.agents import load_tools from langchain.agents import initialize_agent pip install wikipedia from langchain.llms import OpenAI llm = OpenAI(temperature=0) tools = load_tools(["wikipedia", "llm-math"], llm=llm) agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True) agent.run("In what year was the film Departed with Leopnardo Dicaprio released? What is this year raised to the 0.43 power?")

Erinnerung ¶

Status zu Ketten und Agenten hinzufügen.

Speicher ist das Konzept des dauerhaften Zustands zwischen Aufrufen einer Kette/eines Agenten. LangChain bietet eine Standardschnittstelle für Speicher, eine Sammlung von Speicherimplementierungen und Beispiele für Ketten/Agenten, die Speicher verwenden.from langchain import OpenAI, ConversationChain llm = OpenAI(temperature=0) conversation = ConversationChain(llm=llm, verbose=True) conversation.predict(input="Hi there!") conversation.predict(input="Can we talk about AI?") conversation.predict(input="I'm interested in Reinforcement Learning.")

Dokumentenlader ¶

Die Kombination von Sprachmodellen mit Ihren eigenen Textdaten ist eine wirkungsvolle Möglichkeit, diese zu differenzieren. Der erste Schritt dabei besteht darin, die Daten in Dokumente (dh einige Textteile) zu laden. Dieses Modul soll Ihnen dies erleichtern.

Alle verfügbaren Dokumentenlader anzeigen .from langchain.document_loaders import NotionDirectoryLoader loader = NotionDirectoryLoader("Notion_DB") docs = loader.load()

Indizes ¶

Indizes beziehen sich auf Möglichkeiten, Dokumente so zu strukturieren, dass LLMs optimal mit ihnen interagieren können. Dieses Modul enthält Hilfsfunktionen für die Arbeit mit Dokumenten

• Einbettungen: Eine Einbettung ist eine numerische Darstellung einer Information, zum Beispiel Text, Dokumente, Bilder, Audio usw.
• Textteiler: Wenn Sie mit langen Textstücken arbeiten möchten, ist es notwendig, diesen Text in Abschnitte aufzuteilen.
• Vectorstores: Vektordatenbanken speichern und indizieren Vektoreinbettungen aus NLP-Modellen, um die Bedeutung und den Kontext von Textfolgen, Sätzen und ganzen Dokumenten zu verstehen und genauere und relevantere Suchergebnisse zu erhalten. Verfügbare Vectorstores ansehen .

import requests url = "https://raw.githubusercontent.com/hwchase17/langchain/master/docs/modules/state_of_the_union.txt" res = requests.get(url) with open("state_of_the_union.txt", "w") as f: f.write(res.text) # Document Loader from langchain.document_loaders import TextLoader loader = TextLoader('./state_of_the_union.txt') documents = loader.load() # Text Splitter from langchain.text_splitter import CharacterTextSplitter text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) docs = text_splitter.split_documents(documents) pip install sentence_transformers # Embeddings from langchain.embeddings import HuggingFaceEmbeddings embeddings = HuggingFaceEmbeddings() #text = "This is a test document." #query_result = embeddings.embed_query(text) #doc_result = embeddings.embed_documents([text]) pip install faiss-cpu from langchain.vectorstores import FAISS db = FAISS.from_documents(docs, embeddings) query = "What did the president say about Ketanji Brown Jackson" docs = db.similarity_search(query) print(docs[0].page_content) # Save and load: db.save_local("faiss_index") new_db = FAISS.load_local("faiss_index", embeddings) docs = new_db.similarity_search(query) print(docs[0].page_content)

End-to-End-Beispiel ¶

Schauen Sie sich das https://github.com/hwchase17/chat-langchain-Repository an.