Erste Schritte mit weitverbreiteten Frameworks

Voraussetzungen

• Sie verfügen über ein STACKIT Kundenkonto: Ein Kundenkonto erstellen
• Sie verfügen über ein STACKIT Benutzerkonto: Ein Benutzerkonto erstellen
• Sie verfügen über ein STACKIT Projekt: Ein Projekt erstellen

Einbinden eines Chat-Modells in LangChain

LangChain ist eines der geläufigsten Frameworks, um auf LLMs basierende Anwendungen zu erstellen. Dieser Absatz zeigt, wie man einen funktionierenden Ablauf realisiert - das Herzstück der Anwendung.

import os

from dotenv import load_dotenv

load_dotenv("../.env")

model = os.environ["STACKIT_MODEL_SERVING_MODEL"]                           # select a chat-model from https://docs.stackit.cloud/stackit/en/models-licenses-319914532.html
base_url = os.environ["STACKIT_MODEL_SERVING_BASE_URL"]                     # e.g. "https://api.openai-compat.model-serving.eu01.onstackit.cloud/v1"
model_serving_auth_token = os.environ["STACKIT_MODEL_SERVING_AUTH_TOKEN"]   # e.g. "ey..."

Zuerst laden wir Konfigurationen und Secrets, z. B. als Umgebungsvariablen. Wählen Sie ein Chat-Modell mit angemessener Größe. Eine Übersicht über die verfügbaren Modelle finden Sie unter Verfügbare Shared Models. Konsultieren Sie außerdem den Artikel Verwalten von Auth Tokens, um Ihren STACKIT AI Model Serving-Auth-Token einzurichten.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model=model,
    base_url=base_url,
    api_key=model_serving_auth_token,
)

Mit langchain_openai.ChatOpenAIkann auf eine Vielzahl von Modellen zugegriffen werden. Jedes OpenAI API-kompatible Chat-Modell kann verwendet werden. Lesen Sie Verfügbare Shared Models, um ein geeignetes Modell auszuwählen.

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers.string import StrOutputParser

prompt = ChatPromptTemplate([
    ("system", "You are a helpful AI bot."),
    ("human", "Hello, how are you doing?"),
    ("ai", "I'm doing well, thanks!"),
    ("human", "{demand}"),
])

Die ChatPromptTemplate ist eine mögliche Art, ein LLM zu nutzen.

Sie stellt eine Liste von Nachrichten bereit, die eine frühere Unterhaltung nachahmt. Typische Rollen sind human' (Benutzer), AI und system(System). Diesystem-Nachricht ist oft die erste Nachricht, da sie das von dem AI-Bot in diesem Anwendungsfall erwartete Verhalten deklariert und als Anweisung für das Modell dient. Nach der system-Nachricht kann eine Unterhaltung beliebiger Länge den Ton der Interaktion zwischen dem Anwender und der AI bestimmen. Die letzte Nachricht sollte eine Anwender-Nachricht sein, die die eigentliche Benutzeranfrage enthält. Beachten Sie, dass die gesamte Vorlage beim Aufruf an das LLM übergeben wird. Daher müssen die Vorlage, die eigentliche Anfrage des Benutzers und die Antwort in den Kontext des gewählten Modells passen. Es wird empfohlen, concise`-Vorlagen zu verwenden, um höhere Kosten zu vermeiden, da die Services pro Token abgerechnet werden.

Eine Chat-Vorlage kann eine beliebige Anzahl von Platzhaltern enthalten. Ein Wort in geschweiften Klammern wird als Platzhalter betrachtet. Beim Aufruf muss für jeden Platzhalter ein Wert angegeben werden. Typischerweise ist die letzte Nachricht die eigentliche Benutzeranfrage (oder enthält diese), die in diesem Beispiel der einzige Platzhalter ist. Eine offensichtliche Erweiterung des Beispiels zur Verwendung eines zweiten Platzhalters könnte eine zweite system-Anweisung sein, die die answer in einer bestimmten Sprache verlangt, die beim Aufruf angegeben wird.

chain = prompt | llm | StrOutputParser()

demand = "Ask me a riddle."
answer = chain.invoke({"demand": demand})

# Output
# > "When is a door not a door?"

In der ersten Zeile wird über die LangChain Expression Language (LCEL) eine lauffähige Kette konstruiert. Diese einfache Chain kann als eine Abfolge von ausführbaren Elementen gelesen werden. Beim Aufruf werden alle Platzhalter in der prompt template durch die tatsächliche Anfrage ersetzt, und danach wird sie in das Modell eingespeist und die generierte response zu einem plain string geparst. Es ist möglich, mehrere Ketten zu verbinden, um eine komplexere Aufgabe auszuführen. Solche Aufgaben umfassen typischerweise mehrere Modellaufrufe und können advanced Konzepte wie agents oder information retrievers verwenden.

Einbinden eines Chat-Modells in LlamaIndex

LlamaIndex ist ein weiteres weit verbreitetes Framework für das Erstellen von LLM-gesteuerten Anwendungen. Dieser Abschnitt zeigt, wie man ein grundlegendes LLM-Interface einrichtet, um Hands On-Erfahrung zu sammeln.

import os

from dotenv import load_dotenv

load_dotenv("../.env")

model = os.environ["STACKIT_MODEL_SERVING_MODEL"]                           # select a chat-model from https://docs.stackit.cloud/stackit/en/models-licenses-319914532.html
base_url = os.environ["STACKIT_MODEL_SERVING_BASE_URL"]                     # e.g. "https://api.openai-compat.model-serving.eu01.onstackit.cloud/v1"
model_serving_auth_token = os.environ["STACKIT_MODEL_SERVING_AUTH_TOKEN"]   # e.g. "ey..."

Die ersten Schritte sind die gleichen wie die oben für LangChain beschriebenen. Wir müssen ein Chat-Modell auswählen. Lesen Sie Verfügbare Shared Models, um ein passendes Modell auszuwählen und einen STACKIT AI Model Serving-Auth-Token bereitzustellen. Lesen Sie außerdem Verwalten von Auth-Tokens, um einen STACKIT AI Model Serving-Auth-Token einzurichten.

from llama_index.llms.openai import OpenAI

model = OpenAI(
    model=model,
    api_key= model_serving_auth_token,
    api_base=base_url
)

Bei der Arbeit mit LlamaIndex ist llama_index.llms.openai.OpenAI das appropriate interface, um auf jedes openai api-kompatible Modell zuzugreifen. Überprüfen Sie den Verfügbare Shared Models Guide, um ein passendes Modell auszuwählen.

Bei der Arbeit mit LlamaIndex wird das llama_index.llms.OpenAI-Interface verwendet, um auf jedes OpenAI API-kompatible Modell zuzugreifen. Der Verfügbare Shared Models Guide kann überprüft werden, um ein appropriate Modell auszuwählen.

from llama_index.core import ChatPromptTemplate
from llama_index.core.llms import ChatMessage, MessageRole

messages_template = ChatPromptTemplate(
    [
        ChatMessage(
            role=MessageRole.SYSTEM,
            content=(
                "You are {kind_and_mood_of_assistant}\n"
                "--------------------------------------\n"
                "Give your answers in a concise way. Do not use more than 150 character."
            )
        ),
        ChatMessage(role=MessageRole.USER, content="{demand}"),
    ]
)

Das obige Code-Snippet demonstriert, wie eine Anweisung für den LLM Chat-Bot-Assistant vorbereitet wird. Ähnlich wie im LangChain-Beispiel verwenden wir eine Struktur namens ChatMessage. In der Prompt-Template erhält jede Nachricht eine bestimmte Rolle. Die Rolle MessageRole.SYSTEM wird verwendet, um eine Anweisung zu formulieren. Es ist üblich, den Assistant anzuweisen, eine bestimmte Rolle einzunehmen. Der “Helpful AI assistant” ist sehr verbreitet. Jedes Statement in geschweiften Klammern ist ein Platzhalter, die ersetzt werden, wenn eine Anfrage gestellt wird.

Die obige Vorlage ist darauf ausgelegt, eine bestimmte Anfrage zu formulieren und auch die Rolle anzugeben, die das LLM einnehmen soll.

response = model.chat(
    messages_template.format_messages(
        kind_and_mood_of_assistant="a pirate with a colorful personality",
        demand="Who is your best friend?",
    )
)
print(response)
# Output
# > assistant: Me parrot, Squawks! Always by me side, through calm seas and stormy skies.


response = model.chat(
    messages_template.format_messages(
        kind_and_mood_of_assistant="the Mad Hatter",
        demand="Who is your best friend?",
    )
)
print(response)
# Output
# > assistant: The March Hare, of course! We enjoy many a mad tea party together.

Der Zugriff auf das LLM erfolgt über model.chat(...).

Die Template-Platzhalter werden mit der Methode format_messages festgelegt. Im Gegensatz zu LangChain sind die Bezeichnungen der Platzhalter nicht die Schlüssel eines Wörterbuches, sondern “Named Arguments” der Methode. Daher muss die Benennung den “Variable Naming Restrictions” entsprechen, wie z. B. die Verwendung von Unterstrichen anstelle von Leerzeichen.

Die Ausgabe demonstriert die Auswirkung der eingenommenen Rolle sehr gut. Dies kann als “Valuable-Control-Parameter” betrachtet werden.