Belajar Generative AI - Self-Hosted LLM & Ollama/vLLM

#Pendahuluan

Hingga episode 12, kalian selalu memanggil model sebagai layanan (API pihak ketiga atau fine-tune di cloud). Episode ini membaliknya: menjalankan model di mesin kalian sendiri. Self-hosting adalah salah satu keputusan arsitektur paling strategis di 2026 — karena model open-weight (Llama, Qwen, Gemma, DeepSeek) kini setara dengan model closed untuk banyak task, dan membawa keuntungan besar: data tidak keluar dari perimeter, biaya prediktif, dan kontrol penuh.

Mengapa penting? Tiga alasan nyata di dunia kerja: privasi (data pelanggan tidak boleh dikirim ke pihak ketiga), biaya (beban tinggi / skala besar sering lebih murah self-host), dan ketahanan (tidak bergantung uptime vendor). Tapi self-hosting bukan gratis — ada GPU, operasional, dan tuning. Episode ini mengajarkan kapan dan bagaimana melakukannya dengan benar.

#Peta Serving: Ollama vs vLLM

Aturan praktis: Ollama untuk belajar & pengembangan, vLLM untuk produksi. Ollama mengelola model dan API secara ringkas; vLLM mengoptimalkan throughput dengan teknik seperti continuous batching dan paged attention.

#Kebutuhan GPU: Realitas yang Jujur

Sebelum deploy, hitung kebutuhan GPU. Faktor penentunya: ukuran model, quantization, dan konteks yang dipakai.

# bobot model (GB) ≈ parameter (miliar) × bytes per parameter
# FP16 → 2 byte/param; INT8 → 1 byte; INT4 → 0.5 byte
# contoh: 7B model FP16 ≈ 14GB; INT4 ≈ 4-5GB + overhead konteks

Tabel praktis:

Angka ini menjelaskan mengapa quantization begitu penting — ia membuat model besar muat di GPU yang jauh lebih murah, dengan penurunan kualitas yang sering kali tidak signifikan.

#Quantization: GGUF vs AWQ

Quantization memadatkan bobot model dari 16-bit menjadi 8/4-bit. Dua format dominan:

• GGUF: format quantized dari project llama.cpp, dipakai Ollama. Ukuran sangat fleksibel (Q2_K, Q4_K_M, Q8_0), berjalan di CPU maupun GPU.
• AWQ/GPTQ: quantization aware untuk GPU, dioptimalkan untuk throughput vLLM. Menjaga kualitas lebih baik pada ukuran kecil.

ollama pull qwen2.5:7b            # default (Q4_K_M)
ollama pull qwen2.5:14b-instruct  # versi 14B

Prinsipnya: mulai dari Q4_K_M (standar emas GGUF) — keseimbangan kualitas/ukuran terbaik untuk kebanyakan kasus. Naikkan ke Q8 hanya jika butuh kualitas maksimal dan VRAM cukup.

#Praktik 1: Ollama Lokal

Install dan jalankan model pertama:

curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5:7b
ollama run qwen2.5:7b "Jelaskan RAG dalam 2 kalimat"

Ollama menyediakan OpenAI-compatible endpoint — dari episode 5 kita bisa langsung memakainya tanpa mengubah kode:

from openai import OpenAI
 
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",        # bebas, hanya placeholder
)
 
resp = client.chat.completions.create(
    model="qwen2.5:7b",
    messages=[{"role": "user", "content": "Apa itu agent?"}],
)
print(resp.choices[0].message.content)

Perhatikan: satu baris konfigurasi memindahkan aplikasi dari API cloud ke lokal — bukti nyata kekuatan OpenAI-compatible API yang kita bahas di episode 5.

#Praktik 2: vLLM Produksi

Untuk produksi dengan banyak request paralel, gunakan vLLM:

pip install vllm
python3 -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --quantization awq --dtype float16 \
    --max-model-len 32768 \
    --port 8000

vLLM mengekspos endpoint OpenAI-compatible di port 8000 — aplikasi kalian cukup mengganti base_url seperti pada contoh Ollama. Bedanya, vLLM menangani:

• Continuous batching: banyak request diproses paralel dalam satu batch → throughput tinggi.
• PagedAttention: manajemen KV-cache efisien → konteks lebih panjang di VRAM sama.
• Prefill/decoding terpisah: latensi terkontrol.

#Integrasi ke Aplikasi & Deployment

Pola deployment produksi yang umum:

• Jalan di container (Docker) dengan GPU passthrough (--gpus all).
• Pisahkan CPU-heavy (API server) dan GPU-heavy (inference worker).
• Siapkan health check dan auto-restart (episode 18 observability).
• Untuk ketersediaan tinggi, multiple replica + load balancer — vLLM stateless sehingga mudah di-scale.

services:
  vllm:
    image: vllm/vllm-openai:latest
    command:
      - "--model"
      - "Qwen/Qwen2.5-7B-Instruct"
      - "--quantization"
      - "awq"
    ports:
      - "8000:8000"
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]

#Common Pitfalls

• Model terlalu besar untuk VRAM → crash/swap — selalu cek quantization & context length.
• Tanpa model length control → max_model_len default besar menghabiskan VRAM; set sesuai kebutuhan.
• Satu model untuk semua tugas → routing (episode 4) memangkas biaya GPU.
• Self-host tanpa monitoring → tidak tahu model down/generasi lambat; observability di episode 18.

#Penutup

Inti yang harus dibawa pulang:

• Ollama untuk lokal/eksperimen; vLLM untuk produksi throughput tinggi.
• Quantization (GGUF/AWQ) menentukan apakah model muat di GPU kalian.
• Kebutuhan VRAM dihitung dari parameter × bytes/param + konteks.
• Endpoint OpenAI-compatible membuat migrasi cloud ↔ lokal satu baris konfigurasi.

Di episode 14 selanjutnya kita akan membahas Multimodal: Image, Audio & Video — text-to-image (Stable Diffusion 3.5, FLUX.1), TTS/STT (Whisper), vision (VLM), plus pipeline multimodal: input gambar → deskripsi → voice output. Sampai jumpa di episode 14!