LangChain: das Framework für die Entwicklung von Anwendungen mit großen Sprachmodellen

Wenn Sie Anwendungen entwickeln möchten, die große Sprachmodelle (LLM) wie ChatGPT nutzen, haben Sie zwei Möglichkeiten. Sie können die API eines LLM-Anbieters (z. B. die OpenAI-API) direkt verwenden, oder Sie nutzen ein Framework, das die LLM-API abstrahiert und zusätzliche Funktionen bereitstellt.

LangChain ist ein leistungsstarkes Open-Source-Framework für die Entwicklung von Anwendungen, die auf Sprachmodellen basieren. Es integriert sich nahtlos mit den Sprachmodellen Ihrer Wahl, darunter OpenAI oder Hugging Face-Modelle, und kombiniert diese mit externen Quellen wie Ihrem lokalen Dateisystem, Google Drive, Notion oder Wikipedia. Durch die Verbindung dieser Komponenten ermöglicht LangChain es Ihnen, fortgeschrittene Anwendungsfälle rund um Sprachmodelle zu erstellen, indem diese flexibel miteinander verkettet werden.

Klingt immer noch kompliziert und zu abstrakt? Lassen Sie uns das Ganze etwas aufschlüsseln.

#Überblick

Was LangChain besonders attraktiv macht, ist der einfache Einstieg. Wenn Sie Python bevorzugen, können Sie LangChain nutzen, während für diejenigen, die mit JavaScript/TypeScript arbeiten, LangChain.js die passende Wahl ist.

Das Entwicklungs-Framework bietet mehrere zentrale Features und Funktionalitäten, die die Arbeit mit Sprachmodellen (LLMs) erleichtern – aber keine Sorge, für den Anfang kommen Sie mit nur wenigen davon aus:

• LLM Utilities: Dies umfasst eine umfassende Sammlung von Werkzeugen für die nahtlose Interaktion mit LLMs. Diese Utilities beinhalten Prompt-Management, Prompt-Optimierung, eine einheitliche Schnittstelle für alle LLMs sowie verschiedene allgemeine Hilfsmittel wie Document Loader und Parser.
• Chains: LangChain führt ein Konzept namens „Chains” ein, das es Entwicklern ermöglicht, Sequenzen von Aufrufen an LLMs oder andere Werkzeuge wie Datenquellen, APIs oder Bibliotheken zu erstellen. LangChain bietet eine standardisierte Schnittstelle für Chains, zahlreiche Integrationen mit anderen Werkzeugen sowie fertige End-to-End-Chains für gängige Anwendungen.
• Data Augmented Generation: Diese Funktion ermöglicht es Entwicklern, Chains zu erstellen, die mit externen Datenquellen interagieren, um relevante Daten für den Generierungsprozess abzurufen. Sie kann beispielsweise für Aufgaben wie die Zusammenfassung langer Texte oder die Beantwortung von Fragen über bestimmte Datenquellen eingesetzt werden.
• Agents: LangChain stellt einen Mechanismus namens „Agents” bereit, um LLMs zu modellieren, die Entscheidungen treffen, Aktionen ausführen, die Ergebnisse beobachten und den Prozess bis zur Fertigstellung wiederholen. Es bietet eine standardisierte Schnittstelle für Agents, eine Auswahl verfügbarer Agent-Optionen sowie praktische Beispiele für End-to-End-Agents.
• Memory: LangChain unterstützt das Konzept von Memory, das es Entwicklern ermöglicht, Zustandsinformationen zwischen Aufrufen einer Chain oder eines Agents zu persistieren. Es bietet eine standardisierte Schnittstelle für Memory, eine Sammlung von Memory-Implementierungen sowie anschauliche Beispiele von Chains oder Agents, die Memory nutzen.
• Generative Model Evaluation (derzeit in Beta): LangChain führt einen innovativen Ansatz zur Bewertung generativer Modelle ein, bei dem Sprachmodelle selbst für die Evaluierung verwendet werden. Es enthält spezielle Prompts und Chains, die diesen Evaluierungsprozess unterstützen.

LangChain entwickelt sich kontinuierlich weiter und sorgt für beständiges Wachstum und Verbesserung. Dies ermöglicht es Entwicklern, immer fortschrittlichere Anwendungsfälle und Applikationen zu erstellen.

#Sollte ich es verwenden?

Sie sind sich immer noch unsicher, ob Sie LangChain ausprobieren sollten? Meiner Meinung nach lohnt es sich definitiv, selbst wenn Sie gerade erst mit der OpenAI-API anfangen, einige Prompts ausführen und insbesondere, wenn Sie die Antworten programmatisch weiterverarbeiten möchten.

Warum? LangChain abstrahiert das LLM und beinhaltet automatische Wiederholungsversuche als Teil seiner standardisierten Fehlerbehandlung und Resilienz-Features. Diese Funktionalität ermöglicht automatische Wiederholungen in Fällen wie Timeouts oder Erreichen von Anfragelimits und sorgt so für höhere Erfolgsraten und verbesserte Zuverlässigkeit in Sprachverarbeitungs-Workflows. Es unterstützt Sie bei der Spezifikation der Format-Anweisungen, um dem LLM mitzuteilen, welches Ausgabeformat Sie erwarten.

Aber es gibt noch viel mehr. Probieren wir es aus!

#Installation

Bitte erstellen Sie ein neues Python-Projekt in einem neuen Verzeichnis, erstellen Sie eine venv und aktivieren Sie diese.

Installieren Sie dann LangChain und die Module für die gängigen LLM-Anbieter:

pip install langchain[llms]==v0.0.216

Alternativ können Sie die Komponenten einzeln installieren:

pip install langchain
pip install openai

Nach Abschluss der Installation können Sie loslegen und Ihre erste Anwendung erstellen.

#Einfaches Beispiel: „Ein Thema erklären”

Schauen wir uns ein einfaches Beispiel an. Wir möchten eine Anwendung erstellen, die Themen in einfachen Worten erklärt und dafür die OpenAI-API zur Generierung der Antworten nutzt.

Unser Programm soll die Kommandozeilenargumente topic und words unterstützen, um das angegebene Thema in der gewünschten Wortanzahl zu erklären: python3 simple-explainer.py --topic "Large Language Models" --words 100

Zunächst erstellen wir eine Instanz der ChatOpenAI-Klasse, die ein Wrapper um die OpenAI-API ist und das Sprachmodell (LLM) abstrahiert, das wir verwenden möchten. Sie bietet uns eine standardisierte Schnittstelle für die Interaktion mit LLMs.

Dann nutzen wir LLMChain, die LLM-Repräsentation des zentralen Chain-Konzepts, das LangChain seinen Namen gab: Die Chain-Schnittstelle ermöglicht komplexere Anwendungen, die eine Verkettung von LLMs erfordern, entweder untereinander oder mit anderen Komponenten. Eine Chain ist sehr generisch als eine Sequenz von Aufrufen an Komponenten definiert, die auch andere Chains enthalten können. Üblicherweise werden Chains in einer Sequence ausgeführt, aber Sie können auch Router verwenden, um die nächste auszuführende Chain auszuwählen. Wir werden diese Konzepte in einem späteren Beitrag genauer betrachten.

In unserem einfachen Fall möchten wir lediglich einen Prompt ausführen und dann die Antwort verarbeiten. Die LLMChain bietet die standardisierte Schnittstelle für die Interaktion mit LLMs. Sie erleichtert außerdem die Ausführung von Prompts und vereinfacht die Verarbeitung von Antworten des LLM.

Zusätzlich wird ein PromptTemplate instanziiert, um den Prompt vom Code zu trennen und komfortabel Platzhalter im Prompt zu definieren und zu befüllen.

simple-explainer.py

from langchain import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
import argparse

# Kommandozeilenargumente einlesen
parser = argparse.ArgumentParser(description='Run a simple LLM chain.')
parser.add_argument('--topic', type=str, default="Quantum Computing", help='the topic to explain')
parser.add_argument('--words', type=int, default=300, help='the number of words to use')
args = parser.parse_args()

# Neue OpenAI-API-Instanz erstellen und konfigurieren
openai = ChatOpenAI(
    # siehe https://platform.openai.com/docs/api-reference/chat/create#chat/create-temperature
    temperature=0.3,
    # Modell auswählen, das verwendet werden soll
    model_name="gpt-3.5-turbo"
)

# Neue LLMChain-Instanz mit LLM und Prompt-Template erstellen
chain = LLMChain(
    llm=openai,
    prompt=PromptTemplate(
        input_variables=["topic", "words"],
        template="""
            You are an expert teacher. Explain the concept of {topic} in {words} words or less
            in a way that a 12-year-old can understand.
        """
    ),
    verbose=False   # auf True setzen, um den an das LLM gesendeten Prompt zu sehen
)

# Chain ausführen
chain_result = chain.run(
    topic=args.topic,
    words=args.words
)

# Ergebnis ausgeben
print(chain_result)

Um dieses Programm auszuführen, müssen Sie zunächst einen OpenAI-API-Key generieren und ihn als Umgebungsvariable OPENAI_API_KEY setzen.

export OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
python3 simple-explainer.py --topic "Large Language Models" --words 100

Nach der Ausführung des Skripts könnte die Ausgabe folgendermaßen aussehen:

Large Language Models are like super smart computer programs that can understand and
use human language. They can read and analyze lots of text and learn how to write
and speak like humans do. This helps us communicate better with computers and also
helps computers understand us better. Think of them like a really smart language
robot that can talk to us and help us out!

Wir haben festgestellt, dass der Einstieg in LangChain wirklich einfach ist. Der Code ist kompakt und lesbar. Es gibt jedoch noch weitere hilfreiche Features, die wir nutzen können, um unsere Anwendung zu verbessern. Schauen wir uns das nächste Beispiel an.

#Antwort formatieren: „Quiz-Generator”

Das Ausgeben der Antwort eines Sprachmodells (LLM) in der Konsole kann hilfreich sein, doch in vielen Fällen möchte man die Antwort des LLM für bessere Lesbarkeit formatieren oder programmatisch weiterverarbeiten. Beispielsweise müssen Sie möglicherweise bestimmte Teile der Antwort in einer Frontend-Anwendung anzeigen oder Entscheidungen auf Basis der vom LLM generierten Ergebnisse treffen. LangChain bietet eine einfache Möglichkeit, dies zu tun, indem ein Format-String definiert wird, der zur Formatierung der Antwort verwendet wird.

Und noch besser: Sie definieren ein Schema durch ein Pydantic-Modell, das zur Generierung der Formatierungsanweisungen verwendet wird.

Schauen wir uns ein Beispiel an, das ein Quiz basierend auf einem Thema und der Anzahl der zu generierenden Fragen erstellt. Wir verwenden den PydanticOutputParser, um die Antwort zu parsen und die Formatierungsanweisungen zu generieren.

quiz-generator.py

from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
from typing import List

from langchain import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
import argparse

# Kommandozeilenargumente einlesen
parser = argparse.ArgumentParser(description='Generate Quiz')
parser.add_argument('--topic', type=str, default="Vulcan", help='the topic to generate aliases')
parser.add_argument('--count', type=int, default=3, help='the number of suggestions to generate')
args = parser.parse_args()


# Modell für die LLM-Antwort definieren
class Quiz(BaseModel):
    # Beschreibung des Verwendungszwecks der Felder, damit das LLM
    # den Antwortinhalt den Feldern zuordnen kann
    questions: List[str] = Field(description="Quiz-Questions")
    answers: List[str] = Field(description="Quiz-Answers")

    def to_dict(self):
        return {
            "questions": self.questions,
            "answers": self.answers,
        }


quiz_parser: PydanticOutputParser = PydanticOutputParser(
    pydantic_object=Quiz
)

# Neue OpenAI-API-Instanz erstellen und konfigurieren
openai = ChatOpenAI(
    # Siehe https://platform.openai.com/docs/api-reference/chat/create#chat/create-temperature
    temperature=0.3,
    # Modell auswählen, das verwendet werden soll
    model_name="gpt-3.5-turbo"
)

# Neue LLMChain-Instanz mit LLM und Prompt-Template erstellen
chain = LLMChain(
    llm=openai,
    prompt=PromptTemplate(
        input_variables=["topic", "count"],
        # Prompt-Template mit Platzhaltern.
        # Bitte beachten: Die generierten Formatierungsanweisungen für das Ergebnis werden dem Modell
        # über den Platzhalter 'format_instructions' in einer separaten Zeile am Ende des Prompts übergeben
        template="""
                    Ask me {count} questions about {topic}. Provide the answers.
                    \n{format_instructions}
                """,
        # Die aus unserem Modell abgeleiteten format_instructions sofort
        # als 'statischen' Teil des PromptTemplate bereitstellen, die restlichen
        # Variablen werden dynamisch bei chain.run(...) unten übergeben
        partial_variables={
            "format_instructions": quiz_parser.get_format_instructions()
        },
    ),
    verbose=False  # Auf True setzen, um den Prompt mit den generierten Formatierungsanweisungen zu sehen
)

# Chain ausführen
chain_result = chain.run(
    topic=args.topic,
    count=args.count
)

# Ergebnis ausgeben
print(chain_result)

Sie können es mit den Kommandozeilenargumenten topic und count ausführen, um ein Quiz mit der gewünschten Anzahl an Fragen zu generieren: python3 quiz-generator.py --topic "Solar Eclipse" --count 3

Die Ausgabe sieht folgendermaßen aus:

{
  "questions": [
    "What is a solar eclipse?",
    "How often do solar eclipses occur?",
    "What precautions should be taken during a solar eclipse?"
  ],
  "answers": [
    "A solar eclipse occurs when the moon passes between the sun and the earth, blocking the sun's light and casting a shadow on the earth.",
    "Solar eclipses occur about every 18 months, but they are not visible from all parts of the earth each time.",
    "Looking directly at the sun during a solar eclipse can cause permanent eye damage. It is important to wear special eclipse glasses or use other safe viewing methods."
  ]
}

Ziemlich beeindruckend, oder? Wir haben die gewünschte Anzahl an Quizfragen und Antworten im JSON-Format generiert, definiert durch ein Pydantic-Modell. Die JSON-Ausgabe ist eine einfache Datenstruktur, die sich problemlos programmatisch als Antwort einer Quiz-API oder in einer anderen Anwendung verwenden lässt.

#Fazit

Insgesamt bringt LangChain einen erheblichen Vorteil, indem es die Integration großer Sprachmodelle in Anwendungen vereinfacht und fortgeschrittene Anwendungsfälle ermöglicht. Seine benutzerfreundliche Schnittstelle erleichtert die nahtlose Interaktion mit verschiedenen Sprachmodellen und ermöglicht es Entwicklern, komplexe Anwendungen durch Komponentenverkettung zu erstellen. Mit LangChain können Nutzer Anfragen durch Prompt Engineering optimieren und autonome Recherchefähigkeiten nutzen. Letztendlich vereinfacht LangChain die Integration und Nutzung von Sprachmodellen und verbessert die Anwendungsfunktionalität.

In diesem Blogbeitrag haben wir nur an der Oberfläche der leistungsstarken Möglichkeiten von LangChain gekratzt. Wir haben erkundet, wie dieses Framework die Entwicklung von sprachmodellgetriebenen Anwendungen unterstützt. Das Potenzial von LangChain geht jedoch weit über das hier Behandelte hinaus. In zukünftigen Beiträgen werden wir tiefer in einzelne Komponenten, ihre Funktionalitäten und ihre Anpassungsmöglichkeiten für spezifische Anwendungsfälle eintauchen. Bleiben Sie dran für weiterführende Diskussionen und praktische Einblicke, um das bemerkenswerte Potenzial dieses Frameworks voll auszuschöpfen.