Wie man LLM-Anwendungen mit Docker einsetzt: Eine Schritt-für-Schritt-Anleitung

1. Einrichten der Umgebung

Bevor wir die LLM-App erstellen, müssen wir Docker von der offiziellen Website herunterladen und installieren. 

• Installiere Docker auf deinem lokalen System, indem du die Standardoptionen verwendest.
• Als Nächstes erstellst du ein Projektverzeichnis mit deiner Lieblings-IDE und fügst eine .env Datei hinzu. In dieser Datei werden wir die API-Schlüssel für LlamaCloud, MixedBread AI und Groq Cloud speichern.
• Danach meldest du dich bei LlamaCloud an und generierst deinen API-Schlüssel. Wir werden LlamaCloud verwenden, um verschiedene Textformate zu analysieren, darunter Excel, txt, Word und PDFs.

Erzeugen eines neuen Schlüssels in LlamaCloud. Bildquelle: LlamaCloud

• Als Nächstes meldest du dich bei MixedBread AI an und generierst deinen API-Schlüssel. Mit diesem Schlüssel haben wir kostenlosen Zugang zu ihrem Spitzenmodell der Einbettung.

Erstellen eines API-Schlüssels in MixedBread. Bildquelle: MixedBread

• Geh zu GroqCloud und melde dich an, um deinen API-Schlüssel kostenlos zu generieren. Wir werden GroqCloud nutzen, um auf schnelle LLMs zuzugreifen.

Erstellen eines API-Schlüssels in GroqCloud.  Bildquelle: GroqCloud

Erfahre alles über GroqCloud, indem du den Artikel über die Groq LPU Inference Engine liest. Du wirst die Groq-API und ihre Funktionen anhand von Codebeispielen kennenlernen. Außerdem lernst du, wie du mit der Groq API und LlamaIndex kontextbezogene KI-Anwendungen erstellen kannst.

So sollte deine .env Datei aussehen:

LLAMA_CLOUD_API_KEY=llx-XXXXXX
GROQ_API_KEY=gsk_XXXXXXX
MXBAI_API_KEY=emb_XXXXXX

Vergiss nicht, die Datei .env zu deiner .gitignore Datei hinzuzufügen, um zu verhindern, dass deine API-Schlüssel versehentlich öffentlich zugänglich gemacht werden.

2. Erstellung der LLM-Bewerbung

Wir erstellen nun ein Python-Skript namens app.py und fügen die Komponenten der Benutzeroberfläche hinzu, während wir alle KI-Dienste mit LlamaParser integrieren, um die Retrieval-Augmented Generation (RAG) Pipeline mit LlamaIndex zu entwickeln.

Das Skript app.py macht Folgendes:

1. Lade alle notwendigen Python-Pakete.
2. Lade alle API-Schlüssel sicher aus der Datei .env.
3. Initialisiere den LlamaParser mit dem LlamaCloud-API-Schlüssel.
4. Definiere einen Dateiextraktor, der verschiedene gängige Dateierweiterungen verarbeitet.
5. Initialisiere das Einbettungsmodell mit dem MixedBread AI API-Schlüssel, insbesondere das Modell namens mixedbread-ai/mxbai-embed-large-v1.
6. Initialisiere das große Sprachmodell mit dem Groq Cloud API-Schlüssel und dem Modell namens llama-3.1-70b-versatile.

Als Nächstes werden die folgenden Python-Funktionen implementiert:

• load_files(): Diese Funktion lädt die Dateien, parst sie mit dem LlamaParser, wandelt sie in Einbettungen um und speichert sie im Vektorspeicher. Es wird eine Ausnahmebehandlung eingeführt, um Fälle zu behandeln, in denen keine Dateien oder nicht unterstützte Dateiformate hochgeladen werden.
• respond(): Diese Funktion nimmt Benutzereingaben entgegen, ruft Inhalte aus dem Vektorspeicher ab und generiert daraus eine Antwort, die das Groq-Modell nutzt. Die Antwort wird im Streaming-Format generiert, und es werden Ausnahmen behandelt, wenn keine Dateien hochgeladen wurden.

Schließlich werden die UI-Komponenten erstellt, darunter ein Datei-Uploader, Schaltflächen, ein Chat-Feld und die gesamte Chat-Oberfläche.

Erfahre mehr über das LlamaIndex-Framework, indem du dem einfachen LlamaIndex-Tutorial folgst.

Hier ist das app.py Skript:

import os

import gradio as gr
from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.embeddings.mixedbreadai import MixedbreadAIEmbedding
from llama_index.llms.groq import Groq
from llama_parse import LlamaParse

# API keys
llama_cloud_key = os.environ.get("LLAMA_CLOUD_API_KEY")
groq_key = os.environ.get("GROQ_API_KEY")
mxbai_key = os.environ.get("MXBAI_API_KEY")
if not (llama_cloud_key and groq_key and mxbai_key):
    raise ValueError(
        "API Keys not found! Ensure they are passed to the Docker container."
    )

# models name
llm_model_name = "llama-3.1-70b-versatile"
embed_model_name = "mixedbread-ai/mxbai-embed-large-v1"

# Initialize the parser
parser = LlamaParse(api_key=llama_cloud_key, result_type="markdown")

# Define file extractor with various common extensions
file_extractor = {
    ".pdf": parser,
    ".docx": parser,
    ".doc": parser,
    ".txt": parser,
    ".csv": parser,
    ".xlsx": parser,
    ".pptx": parser,
    ".html": parser,
    ".jpg": parser,
    ".jpeg": parser,
    ".png": parser,
    ".webp": parser,
    ".svg": parser,
}

# Initialize the embedding model
embed_model = MixedbreadAIEmbedding(api_key=mxbai_key, model_name=embed_model_name)

# Initialize the LLM
llm = Groq(model="llama-3.1-70b-versatile", api_key=groq_key)


# File processing function
def load_files(file_path: str):
    global vector_index
    if not file_path:
        return "No file path provided. Please upload a file."
   
    valid_extensions = ', '.join(file_extractor.keys())
    if not any(file_path.endswith(ext) for ext in file_extractor):
        return f"The parser can only parse the following file types: {valid_extensions}"

    document = SimpleDirectoryReader(input_files=[file_path], file_extractor=file_extractor).load_data()
    vector_index = VectorStoreIndex.from_documents(document, embed_model=embed_model)
    print(f"Parsing completed for: {file_path}")
    filename = os.path.basename(file_path)
    return f"Ready to provide responses based on: {filename}"


# Respond function
def respond(message, history):
    try:
        # Use the preloaded LLM
        query_engine = vector_index.as_query_engine(streaming=True, llm=llm)
        streaming_response = query_engine.query(message)
        partial_text = ""
        for new_text in streaming_response.response_gen:
            partial_text += new_text
            # Yield an empty string to cleanup the message textbox and the updated conversation history
            yield partial_text
    except (AttributeError, NameError):
        print("An error occurred while processing your request.")
        yield "Please upload the file to begin chat."


# Clear function
def clear_state():
    global vector_index
    vector_index = None
    return [None, None, None]


# UI Setup
with gr.Blocks(
    theme=gr.themes.Default(
        primary_hue="green",
        secondary_hue="blue",
        font=[gr.themes.GoogleFont("Poppins")],
    ),
    css="footer {visibility: hidden}",
) as demo:
    gr.Markdown("# DataCamp Doc Q&A 🤖📃")
    with gr.Row():
        with gr.Column(scale=1):
            file_input = gr.File(
                file_count="single", type="filepath", label="Upload Document"
            )
            with gr.Row():
                btn = gr.Button("Submit", variant="primary")
                clear = gr.Button("Clear")
            output = gr.Textbox(label="Status")
        with gr.Column(scale=3):
            chatbot = gr.ChatInterface(
                fn=respond,
                chatbot=gr.Chatbot(height=300),
                theme="soft",
                show_progress="full",
                textbox=gr.Textbox(
                    placeholder="Ask questions about the uploaded document!",
                    container=False,
                ),
            )

    # Set up Gradio interactions
    btn.click(fn=load_files, inputs=file_input, outputs=output)
    clear.click(
        fn=clear_state,  # Use the clear_state function
        outputs=[file_input, output],
    )

# Launch the demo
if __name__ == "__main__":
    demo.launch()

• Führe die obige Python-Datei aus, um den Gradio-Server mit folgendem Befehl in deinem Terminal zu starten:

$ python app.py  

Ausgabe:

• Du kannst auf die Grodio-Benutzeroberfläche zugreifen, indem du die generierte URL kopierst und in deinen Browser einfügst. Dann kannst du eine Datei hochladen und anfangen, Fragen dazu zu stellen.

Zugriff auf die Gradio-App über den Browser. Bild vom Autor

Wir verwenden LlamaIndex, um unsere LLM-Anwendung für diesen Lehrgang zu erstellen. Du kannst eine ähnliche Anwendung mit LangChain erstellen, indem du den Kurzkurs Developing LLM Applications with LangChain belegst.

3. Erstellen des Dockerfiles

• Erstelle in deinem Projekt eine Dockerfile, um das Anwendungsskript, die Python-Abhängigkeiten und die Serverkonfigurationen zu verpacken und den Gradio-Server zu initialisieren. 

Die Dockerfile übernimmt die folgenden Aufgaben:

1. Richte eine Python 3.9 Umgebung ein.
2. Lege das Arbeitsverzeichnis fest.
3. Kopiere die Datei requirements.txt in das Verzeichnis /app. Diese Datei enthält die Namen aller benötigten Python-Pakete.
4. Installiere alle Abhängigkeiten, die in der Datei requirements.txt angegeben sind.
5. Kopiere die Datei app.py in das Verzeichnis /app.
6. Schalte den Port frei und gib die URL des Gradio-Servers an.
7. Führe die Anwendungsdatei aus, um den Server zu starten.

So sollte die Dockerfile aussehen:

# Dockerfile

# Use the official Python image with the desired version
FROM python:3.9-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the requirements file to the working directory
COPY requirements.txt /app

# Install the dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code to the working directory
COPY app.py /app

# Expose the port that Gradio will run on (default is 7860)
EXPOSE 7860

ENV GRADIO_SERVER_NAME="0.0.0.0"

# Command to run your application
CMD ["python", "app.py"]

• Und so sieht die Datei requirements.txt aus. Füge sie auch zu deinem Projekt hinzu:

gradio
llama-index-embeddings-mixedbreadai
llama-index-llms-groq
llama-index

4. Erstellen des Docker-Images und Ausführen des Containers

• Gib den folgenden Befehl in das Terminal ein, um das docqa Docker-Image zu erstellen. Es wird die Dockerfile verwenden, um das Docker-Image zu erstellen.

$ docker build -t docqa . 

Wir können die Protokolle der Prozesse sehen, die während der Erstellung des Docker-Images ablaufen:

Erstellen des LLM-Docker-Images. Bild vom Autor

• Sobald das Image erfolgreich erstellt wurde, gehst du zum Docker-Desktop und klickst auf die Schaltfläche Images und klicke auf das Docker-Image, um die Protokolle und verschiedene Anweisungen zum Ausführen des Images zu sehen.

Anzeige des Docker-Images auf dem Docker-Desktop. Bild vom Autor

Wir werden nun den Docker-Container lokal mit dem Image ausführen. Wir geben ihm die Portnummer, eine .env Datei zum Einrichten von Umgebungsvariablen, den Namen des Docker Containers und das Docker Image Tag.

• Führe den folgenden Befehl in deinem Terminal aus: 

$ docker run -p 7860:7860 --env-file .env --name docqa-container docqa

Sobald der Container läuft, kannst du auf die Gradio-App zugreifen, indem du die URL, in diesem Fall http://0.0.0.1:7860/, in den Browser einfügst. 

Testen der LLM-Anwendung im Docker-Container. Bild vom Autor

• Um die Informationen zu allen lokal laufenden Containern anzuzeigen, gibst du den folgenden Befehl ein:

$ docker ps

Ausgabe:

CONTAINER ID   IMAGE     COMMAND           CREATED          STATUS          PORTS                    NAMES
ff2a11da13d7   docqa     "python app.py"   17 seconds ago   Up 16 seconds   0.0.0.0:7860->7860/tcp   docqa-container

• Du kannst den Docker-Container mit dem Befehl stop anhalten:

$ docker stop docqa-container 

• Du kannst sie auch mit dem Befehl rm entfernen:

$ docker rm docqa-container 

Sobald wir ein Docker-Image haben, können wir unsere LLM-Anwendung überall einsetzen: GCP, AWS, Azure oder jeder andere Cloud-Server, der die Docker-Bereitstellung unterstützt.

5. Bereitstellung der LLM-Anwendung in Hugging Face mit Docker

Um es Anfängern zu erleichtern, werden wir die App mit Docker in der Hugging Face Cloud (Spaces) bereitstellen. 

• Gehe zum Hugging Face Dashboard, klicke auf das Profilbild und wähle + Neuer Raum.
• Gib deinem Space einen Namen, füge eine kurze Beschreibung hinzu, wähle die Lizenz und das SDK und erstelle das Space-Repository.

Erstellen des neuen Hugging Face Space mit Docker. Bild Quelle: Hugging Face

Sobald das Space-Repository erstellt ist, erhältst du Anweisungen, wie du es klonen und die erforderlichen Dateien hinzufügen kannst.

• Um das Repository zu klonen, verwende den folgenden Befehl (aktualisiere die URL auf diejenige, die auf deinen Space verweist):

$ git clone https://huggingface.co/spaces/kingabzpro/doc-qa-docker

• Kopiere alle Dateien aus dem Projektverzeichnis und füge sie in das neue Repository ein:

So sollte dein Projektverzeichnis mit allen Dateien aussehen. Achte immer darauf, dass du die Datei .env nicht pushst, also füge sie der .gitignore hinzu. 

Struktur der Projektdatei. Bild vom Autor

• Setze die Dateien in Szene, gib eine Nachricht ein und schiebe sie dann in den Hugging Face Space:

$ git add .                                                                                            
$ git commit -m "Deploying the App" 
$ git push

Ausgabe:

Enumerating objects: 8, done.
Counting objects: 100% (8/8), done.
Delta compression using up to 16 threads
Compressing objects: 100% (7/7), done.
Writing objects: 100% (7/7), 7.60 KiB | 7.60 MiB/s, done.
Total 7 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To https://huggingface.co/spaces/kingabzpro/doc-qa-docker
   afb20ad..5ca6388  main -> main

• Gehe zu deinem Hugging Face Space, um die Anwendung aufzurufen. Er erstellt das Docker-Image und stellt dann die Anwendung bereit:

Erstellen des Docker-Images in der Hugging Face Cloud. Bildquelle: Doc Qa Docker

Wenn du eine Fehlermeldung wie die unten stehende siehst, mach dir keine Sorgen. Es liegt an fehlenden Umgebungsvariablen. Alles, was wir tun müssen, ist, diese Variablen im Hugging Face Space einzurichten.

Laufzeitfehler in der bereitgestellten App. Bildquelle: Doc Qa Docker

• Um eine neue Umgebungsvariable in deinem Space hinzuzufügen, gehe zu Einstellungen, scrolle nach unten und klicke auf die SchaltflächeNeues Geheimnis. Dann gibst du den Namen und den Wert für den Umgebungswert an, wie unten gezeigt. In diesem Fall fügen wir die notwendigen API-Schlüssel hinzu:

Hinzufügen von Geheimnissen zu der bereitgestellten App. Bildquelle: Doc Qa Docker-Einstellungen.

So sollten deine Geheimnisse aussehen, nachdem du alle notwendigen API-Schlüssel als Umgebungsvariablen hinzugefügt hast:

Geheimnisse für die eingesetzte App. Bildquelle: Doc Qa Docker-Einstellungen.

Sobald du die Geheimnisse eingerichtet hast, wird die App automatisch neu gestartet und du solltest sehen, dass die App läuft. Nutze sie und genieße deine Q&A-Anwendung in der Cloud!

LLM-App auf den Hugging Face Spaces. Bildquellee: Doc Qa Docker

Um die Ergebnisse zu reproduzieren, findest du alle Dateien und Konfigurationen im GitHub-Repositoriumsitory: kingabzpro/Deploy-Doc-QA.

6. Überwachung der bereitgestellten Anwendung

Die Nutzung von KI-Diensten hat Vorteile: Du musst keine Dienste einrichten oder verwalten, du bekommst einen hohen Durchsatz und ein Dashboard mit den Protokollen. 

Dein LlamaCloud Dashboard protokolliert alle Dokumente, die geparst wurden. Du kannst dir die Historie ansehen oder die Nutzung anfordern und vergleichen. 

Llama Cloud Dashboard. Bild source: LlamaCloud 

Du kannst auch die Anzahl der Token, die wir für das Einbettungsmodell verwendet haben, und die Anzahl der generierten Anfragen überprüfen. 

Mixedbread Dashboard. Bildquellee: Mischbrot

Die detailliertesten Logs für jede API findest du in der GroqCloud, mit Informationen über die Latenz, die Anzahl der Token, den AI-Schlüssel und die Request-ID, damit du das System debuggen kannst.

GroqCloud logs. Bild source: GroqCloud

Schlussgedanken

In diesem Leitfaden haben wir gelernt, wie wir mehrere Dienste kombinieren können, um eine effiziente Q&A-Anwendung mit minimalem Ressourcenverbrauch und Rechenaufwand zu erstellen. Alle Dienste und Tools, die wir verwendet haben, sind frei verfügbar, damit du deine eigene Anwendung testen und erstellen kannst.

Wir haben die Größe unseres Docker-Images um 600 MB reduziert, indem wir mehrere sofort einsatzbereite KI-Dienste genutzt haben. Hätten wir alles selbst implementiert, wäre das Image 20 GB oder mehr groß gewesen. 

Ich empfehle die LLMOps Concepts: From Ideation to Deployment ist der nächste Schritt auf deiner Lernreise. In diesem Kurs erhältst du Einblicke in den Lebenszyklus der LLM-Entwicklung und in die Herausforderungen bei der Bereitstellung von Anwendungen. Außerdem lernst du, wie du diese Konzepte effektiv anwenden kannst.