Cara Mendeploy Aplikasi LLM Menggunakan Docker: Panduan Langkah demi Langkah

Deskripsi Proyek

Ada dua pendekatan utama untuk mengembangkan dan mendeploy aplikasi AI:

• Sepenuhnya open source: Pendekatan ini menekankan privasi dan perlindungan data.
• Sepenuhnya closed source: Metode ini melibatkan integrasi banyak API dan layanan cloud.

Kedua pendekatan memiliki kelebihan dan kekurangan. Dalam kasus kami, kami memilih pendekatan kedua, yaitu mengintegrasikan beberapa layanan AI. Ini memungkinkan kami membangun aplikasi AI yang cepat yang hanya membutuhkan beberapa detik untuk dibangun dan dideploy. Fokus utama kami adalah mengurangi ukuran image Docker, yang dapat dicapai secara efektif dengan mengintegrasikan banyak layanan AI.

Lihat tutorial Local AI with Docker, n8n, Qdrant, and Ollama untuk membangun aplikasi LLM menggunakan alat dan kerangka kerja open-source demi peningkatan privasi!

Kita akan membangun chatbot Q&A serbaguna yang memungkinkan pengguna mengunggah dokumen dan mengobrol dengannya secara real time. Ini cukup mirip dengan NotebookLM milik Google.

Diagram proyek. Gambar oleh Penulis

Berikut adalah alat yang akan kita gunakan dalam proyek ini:

1. Gradio Blocks: Untuk membuat antarmuka pengguna yang memungkinkan pengguna mengunggah dokumen teks apa pun dan mengobrol dengan dokumen tersebut dengan mudah.
2. LlamaCloud: Untuk mem-parsing file dan mengekstrak data teks dalam gaya markdown.
3. MixedBread AI: Digunakan untuk mengonversi dokumen yang dimuat dan pesan obrolan menjadi embedding untuk pengambilan konteks.
4. Groq Cloud: Untuk mengakses respons LLM yang cepat. Dalam proyek ini, kita akan menggunakan model llama-3.1-70b.
5. LlamaIndex: Untuk membuat pipeline RAG (Retrieval Augmented Generation) yang mengorkestrasi semua layanan AI. Pipeline akan menggunakan file yang diunggah dan pesan pengguna untuk menghasilkan jawaban yang kontekstual.
6. Docker: Digunakan untuk mengenkapsulasi aplikasi, dependensi, lingkungan, dan konfigurasi.
7. Hugging Face Cloud: Kita akan mendorong semua file ke repositori Spaces, dan Hugging Face akan otomatis membangun image menggunakan Dockerfile dan mendeploy-nya ke server.

Jika Anda baru mengenal LLM, pertimbangkan untuk mengambil kursus Master Large Language Models (LLMs) Concepts untuk mempelajari terminologi dasar, metodologi, pertimbangan etis, dan riset terbaru.

1. Menyiapkan Lingkungan

Sebelum membangun aplikasi LLM, kita perlu mengunduh dan menginstal Docker dari situs resmi. 

• Instal Docker di sistem lokal Anda menggunakan opsi bawaan.
• Selanjutnya, buat direktori proyek menggunakan IDE favorit Anda dan tambahkan file .env. Kita akan menggunakan file ini untuk menyimpan API key untuk LlamaCloud, MixedBread AI, dan Groq Cloud.
• Setelah itu, daftar ke LlamaCloud dan buat API key Anda. Kita akan menggunakan LlamaCloud untuk mem-parsing berbagai format teks, termasuk Excel, txt, Word, dan PDF.

Membuat key baru di LlamaCloud. Sumber gambar: LlamaCloud

• Berikutnya, daftar ke MixedBread AI dan buat API key Anda. Kita akan menggunakan key ini untuk mengakses model embedding kelas atas mereka secara gratis.

Membuat API key di MixedBread. Sumber gambar: MixedBread

• Kunjungi GroqCloud dan daftar untuk membuat API key Anda secara gratis. Kita akan menggunakan GroqCloud untuk mengakses LLM berkecepatan tinggi.

Membuat API key di GroqCloud.  Sumber gambar: GroqCloud

Pelajari semua tentang GroqCloud dengan membaca artikel tentang Groq LPU Inference Engine. Anda akan mempelajari Groq API dan fiturnya dengan contoh kode. Selain itu, pelajari cara membangun aplikasi AI kontekstual menggunakan Groq API dan LlamaIndex.

Beginilah tampilan file .env Anda:

LLAMA_CLOUD_API_KEY=llx-XXXXXX
GROQ_API_KEY=gsk_XXXXXXX
MXBAI_API_KEY=emb_XXXXXX

Ingat untuk menambahkan file .env ke file .gitignore agar tidak sengaja mengekspos API key Anda ke publik.

2. Membangun Aplikasi LLM

Sekarang kita akan membuat skrip Python bernama app.py dan menambahkan komponen antarmuka pengguna sambil mengintegrasikan semua layanan AI menggunakan LlamaParser untuk mengembangkan pipeline Retrieval-Augmented Generation (RAG) dengan LlamaIndex.

Skrip app.py akan melakukan hal-hal berikut:

1. Memuat semua paket Python yang diperlukan.
2. Memuat semua API key dari file .env secara aman.
3. Menginisialisasi LlamaParser menggunakan API key LlamaCloud.
4. Mendefinisikan file extractor yang menangani berbagai ekstensi file umum.
5. Menginisialisasi model embedding menggunakan API key MixedBread AI, khususnya model bernama mixedbread-ai/mxbai-embed-large-v1.
6. Menginisialisasi large language model menggunakan API key Groq Cloud dan model bernama llama-3.1-70b-versatile.

Berikutnya, skrip akan mengimplementasikan fungsi Python berikut:

• load_files(): Fungsi ini akan memuat file, mem-parsing-nya menggunakan LlamaParser, mengonversinya menjadi embedding, dan menyimpannya di vector store. Penanganan pengecualian akan disertakan untuk menangani kasus ketika yang diunggah bukan file atau format file tidak didukung.
• respond(): Fungsi ini akan mengambil input pengguna, mengambil konten dari vector store, dan menggunakannya untuk menghasilkan respons menggunakan model Groq. Pembuatan respons akan dalam format streaming, dan penanganan pengecualian akan disertakan jika belum ada file yang diunggah.

Terakhir, skrip akan membangun komponen UI, termasuk pengunggah file, tombol, kotak obrolan, dan keseluruhan antarmuka chat.

Pelajari lebih lanjut tentang kerangka kerja LlamaIndex dengan mengikuti tutorial LlamaIndex yang lebih sederhana.

Berikut skrip app.py:

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()

• Jalankan file Python di atas untuk memulai server Gradio menggunakan perintah berikut di terminal Anda:

$ python app.py  

Keluaran:

• Anda dapat mengakses UI Grodio dengan menyalin dan menempelkan URL yang dihasilkan ke browser. Lalu, unggah file dan mulai ajukan pertanyaan tentang file tersebut.

Mengakses aplikasi Gradio di browser. Gambar oleh Penulis

Kami menggunakan LlamaIndex untuk mendeploy dan membangun aplikasi LLM dalam tutorial ini. Anda dapat membangun aplikasi serupa dengan LangChain melalui kursus singkat Developing LLM Applications with LangChain.

3. Membuat Dockerfile

• Di proyek Anda, buat Dockerfile untuk mengemas skrip aplikasi, dependensi Python, dan konfigurasi server sambil menginisialisasi server Gradio. 

Dockerfile akan melakukan tugas-tugas berikut:

1. Menyiapkan lingkungan Python 3.9.
2. Mendefinisikan direktori kerja.
3. Menyalin file requirements.txt ke direktori /app. File ini berisi nama semua paket Python yang diperlukan.
4. Menginstal semua dependensi yang ditentukan di file requirements.txt.
5. Menyalin file app.py ke direktori /app.
6. Mengekspos port dan mengatur URL server Gradio.
7. Menjalankan file aplikasi untuk memulai server.

Berikut tampilan Dockerfile yang seharusnya:

# 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"]

• Dan berikut tampilan file requirements.txt. Tambahkan juga ke proyek Anda:

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

4. Membangun Docker Image dan Menjalankan Container

• Ketik perintah berikut di terminal untuk membangun image docker docqa. Perintah ini akan menggunakan Dockerfile untuk membuat Docker image.

$ docker build -t docqa . 

Kita dapat melihat log proses yang berlangsung saat membangun Docker image:

Membangun Docker image LLM. Gambar oleh Penulis

• Setelah image berhasil dibuat, buka Docker Desktop, klik tab Images, lalu klik Docker image untuk melihat log dan berbagai instruksi untuk menjalankan image. 

Melihat Docker image di Docker Desktop. Gambar oleh Penulis

Sekarang kita akan menjalankan container Docker secara lokal menggunakan image tersebut. Kita akan memberikan nomor port, file .env untuk menyiapkan variabel lingkungan, nama container Docker, dan tag Docker image.

• Jalankan perintah berikut di terminal Anda: 

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

Setelah container mulai berjalan, Anda dapat mengakses aplikasi Gradio dengan menempelkan URL, dalam kasus ini, http://0.0.0.1:7860/ di browser. 

Menguji aplikasi LLM container Docker. Gambar oleh Penulis

• Untuk melihat informasi semua container yang berjalan secara lokal, ketik perintah berikut:

$ docker ps

Keluaran:

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

• Anda dapat menghentikan container Docker menggunakan perintah stop:

$ docker stop docqa-container 

• Anda juga dapat menghapusnya menggunakan perintah rm:

$ docker rm docqa-container 

Setelah kita memiliki Docker image, kita dapat mendeploy aplikasi LLM kita ke mana saja: GCP, AWS, Azure, atau server cloud mana pun yang mendukung deployment Docker.

5. Mendeploy Aplikasi LLM ke Hugging Face Menggunakan Docker

Untuk menyederhanakan bagi pemula, kita akan mendeploy aplikasi menggunakan Docker di Hugging Face Cloud (Spaces). 

• Buka dasbor Hugging Face, klik pada gambar profil, lalu pilih + New Space.
• Beri nama Space Anda, tambahkan deskripsi singkat, pilih lisensi dan SDK, lalu buat repositori Space.

Membuat Hugging Face Space baru menggunakan Docker. Sumber gambar: Hugging Face

Setelah repositori Space dibuat, Anda akan menerima instruksi tentang cara mengkloningnya dan menambahkan file yang diperlukan.

• Untuk mengkloning repositori, gunakan perintah berikut (perbarui URL ke yang mengarah ke Space Anda):

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

• Salin dan tempel semua file dari direktori proyek ke repositori baru:

Seperti inilah tampilan direktori proyek Anda dengan semua file. Selalu pastikan Anda tidak mendorong file .env, jadi tambahkan ke .gitignore. 

Struktur file proyek. Gambar oleh Penulis

• Stage file, lakukan commit dengan pesan, lalu push ke Hugging Face Space:

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

Keluaran:

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

• Buka Hugging Face Space Anda untuk mengakses aplikasi. Space akan membangun Docker image dan kemudian menyajikan aplikasi:

Membangun Docker image di Hugging Face Cloud. Sumber gambar: Doc Qa Docker

Jika Anda melihat error seperti di bawah ini, jangan khawatir. Ini disebabkan oleh variabel lingkungan yang belum diset. Yang perlu kita lakukan adalah menyiapkan variabel tersebut di Hugging Face Space.

Runtime error pada aplikasi yang dideploy. Sumber gambar: Doc Qa Docker

• Untuk menambahkan variabel lingkungan baru di Space Anda, buka Settings, gulir ke bawah, dan klik tombol New secret. Lalu, berikan nama dan nilai untuk variabel lingkungan, seperti di bawah ini. Dalam kasus ini, kita menambahkan API key yang diperlukan:

Menambahkan secrets ke aplikasi yang dideploy. Sumber gambar: Pengaturan Doc Qa Docker.

Seperti inilah tampilan secrets Anda setelah menambahkan semua API key yang diperlukan sebagai variabel lingkungan:

Secrets untuk aplikasi yang dideploy. Sumber gambar: Pengaturan Doc Qa Docker.

Setelah Anda menyiapkan secrets, aplikasi akan restart secara otomatis, dan Anda akan melihat aplikasi berjalan. Gunakan dan nikmati aplikasi Q&A dokumen Anda di cloud!

Aplikasi LLM di Hugging Face Spaces. Sumber gambar: Doc Qa Docker

Untuk mereplikasi hasilnya, semua file dan konfigurasi dapat ditemukan di repo GitHubsitory: kingabzpro/Deploy-Doc-QA.

6. Memantau Aplikasi yang Dideploy

Menggunakan layanan AI memiliki keunggulan: Anda tidak perlu mendeploy atau mengelola layanan apa pun, Anda mendapatkan throughput tinggi, dan Anda mendapat dasbor dengan log. 

Dasbor LlamaCloud Anda mencatat semua dokumen yang telah diparsing. Anda dapat memeriksa riwayat atau permintaan dan membandingkan penggunaan. 

Dasbor Llama Cloud. Sumber: LlamaCloud 

Demikian pula, Anda juga dapat memeriksa jumlah token yang kita gunakan untuk model embedding dan jumlah permintaan yang dihasilkan. 

Dasbor Mixedbread. Sumber gambar: Mixedbread

Log paling detail dari setiap API dapat ditemukan di GroqCloud, dengan informasi tentang latensi, jumlah token, kunci AI, dan ID permintaan untuk membantu Anda men-debug sistem.

Log GroqCloud. Sumber gambar: GroqCloud

Penutup

Panduan ini mengajarkan kita cara menggabungkan beberapa layanan untuk membangun aplikasi Q&A dokumen yang efisien dengan penggunaan sumber daya dan beban komputasi minimal. Semua layanan dan alat yang kita gunakan tersedia gratis untuk Anda uji dan bangun aplikasi Anda sendiri.

Kami telah mengurangi ukuran Docker image sebesar 600MB dengan menggunakan beberapa layanan AI siap pakai. Jika kami mendeploy semuanya sendiri, ukuran image akan sekitar 20GB atau lebih. 

Saya merekomendasikan mengambil kursus LLMOps Concepts: From Ideation to Deployment sebagai langkah berikutnya dalam perjalanan belajar Anda. Kursus ini akan membantu Anda memperoleh wawasan tentang siklus pengembangan LLM dan tantangan dalam mendeploy aplikasi. Kursus ini juga akan mengajarkan cara menerapkan konsep-konsep tersebut secara efektif.