DEV Community

Cover image for Cara Menggunakan LLM Lokal Sebagai API
Walse
Walse

Posted on • Originally published at apidog.com

Cara Menggunakan LLM Lokal Sebagai API

Laptop Anda dapat menjalankan model 70B di balik endpoint bergaya OpenAI yang sama dengan endpoint produksi. Ubah satu base_url, dan kode klien tetap berjalan. Dengan pola ini, Anda bisa mengembangkan secara offline, mengurangi biaya per-token saat development, dan menjaga data sensitif tetap berada di perangkat sendiri. Panduan ini menunjukkan cara memilih runtime lokal, mengekspos endpoint, mengarahkan SDK OpenAI ke endpoint tersebut, lalu menguji alurnya dengan Apidog sebelum mempromosikan perubahan ke model hosted.

Coba Apidog hari ini

TL;DR

Anda dapat menjalankan API LLM lokal di laptop dengan Ollama, vLLM, atau llama.cpp. Ketiganya dapat mengekspos endpoint REST yang kompatibel dengan OpenAI.

Contoh perubahan utama:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",
)
Enter fullscreen mode Exit fullscreen mode

Dengan mengganti base_url, kode yang sebelumnya memanggil https://api.openai.com/v1 dapat diarahkan ke model lokal seperti Llama 3.3, DeepSeek V4, atau Qwen 3.6 tanpa menulis ulang integrasi. Gunakan Apidog untuk menjalankan skenario pengujian yang sama terhadap target lokal dan hosted.

Pendahuluan

Tumpukan API LLM lokal telah berubah dari eksperimen riset menjadi workflow harian developer. Apple menyediakan memori terpadu besar pada M3 Max. Ollama mencapai jutaan unduhan. vLLM menjadi runtime populer untuk serving throughput tinggi. Perubahan paling penting bagi developer API adalah konsistensi format: runtime utama sekarang dapat berbicara lewat endpoint seperti /v1/chat/completions.

Artinya, Anda tidak perlu mempertahankan dua jalur klien. SDK OpenAI yang sama dapat diarahkan ke localhost atau api.openai.com melalui satu variabel lingkungan.

Jika template request Anda di Apidog saat ini menunjuk ke:

https://api.openai.com/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Anda cukup mengganti host menjadi:

http://localhost:11434/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Respons tetap berbentuk JSON yang sama. Tidak ada skema baru. Tidak ada pola autentikasi baru. Jika Anda sudah melacak pengeluaran API per fitur, Anda dapat melakukan A/B test antara model lokal dan hosted, lalu membandingkan biaya, latensi, dan kualitas output.

Panduan ini membahas:

  • pilihan runtime lokal,
  • setup server,
  • koneksi dari Python dan JavaScript,
  • pengujian skenario dengan Apidog,
  • trade-off kuantisasi,
  • perbandingan biaya dan latensi.

Untuk gambaran pilihan model yang lebih luas, lihat LLM Lokal Terbaik 2026.

Mengapa LLM lokal berguna untuk developer API

LLM lokal membantu saat Anda perlu men-debug integrasi tanpa koneksi internet, saat bekerja di jaringan pelanggan yang membatasi akses keluar, atau saat prompt berisi data yang tidak boleh dikirim ke layanan pihak ketiga.

Ada tiga alasan utama.

1. Development tetap berjalan tanpa jaringan

Dengan endpoint lokal, aplikasi tetap bisa memanggil API LLM saat:

  • Wi-Fi buruk,
  • environment pelanggan memblokir *.openai.com,
  • CI runner berada di jaringan tertutup,
  • Anda ingin menjalankan regression test tanpa biaya token.

2. Data sensitif tidak keluar dari mesin

Prompt sering berisi data pengguna: kontrak, log internal, catatan pasien, atau identifier lain. Saat dikirim ke endpoint hosted, Anda harus menangani dokumentasi pemrosesan data, audit, dan kebijakan transfer.

Dengan model lokal, payload tetap berada di hardware Anda. Ini berguna untuk workload yang dikendalikan oleh HIPAA, GDPR, UU AI UE, atau kebijakan internal perusahaan.

3. Perilaku model lebih stabil

Model hosted dapat berubah, diganti, atau dihentikan. Model lokal adalah file di disk. Jika Anda menyimpan model dan versi kuantisasinya, output lebih mudah direproduksi untuk regression test.

Keuntungannya menjadi praktis karena endpoint lokal sekarang kompatibel dengan OpenAI. Anda mendapat stabilitas tanpa membayar “pajak integrasi” berupa SDK dan skema baru.

Tiga runtime yang menyediakan endpoint kompatibel OpenAI

Pilih runtime berdasarkan kebutuhan deployment, bukan popularitas.

Runtime Cocok untuk Endpoint default
Ollama Laptop, demo, CI sederhana http://localhost:11434/v1
vLLM Server GPU, throughput tinggi http://localhost:8000/v1
llama.cpp Hardware beragam, kontrol kuantisasi port sesuai llama-server

1. Ollama

Ollama adalah jalur paling sederhana untuk memulai. Satu binary, satu CLI, dan server HTTP di port 11434. Ollama menangani download model, format GGUF, dan template prompt.

Ollama

Install dan jalankan di macOS:

brew install ollama
ollama serve &
ollama pull llama3.3:70b-instruct-q4_K_M
ollama run llama3.3:70b-instruct-q4_K_M
Enter fullscreen mode Exit fullscreen mode

Endpoint kompatibel OpenAI tersedia di:

http://localhost:11434/v1
Enter fullscreen mode Exit fullscreen mode

Contoh cek cepat:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ollama" \
  -d '{
    "model": "llama3.3:70b-instruct-q4_K_M",
    "messages": [
      { "role": "user", "content": "Reply with OK only." }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Gunakan Ollama untuk:

  • development lokal,
  • demo offline,
  • pengujian prompt,
  • CI runner dengan model kecil,
  • prototyping sebelum memakai endpoint hosted.

2. vLLM

vLLM cocok untuk serving bersama di server GPU. Runtime ini memakai PagedAttention dan batching berkelanjutan untuk throughput lebih tinggi dibanding runner sederhana.

vLLM

Install dan jalankan:

pip install vllm

vllm serve meta-llama/Llama-3.3-70B-Instruct \
  --port 8000 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 8192
Enter fullscreen mode Exit fullscreen mode

Endpoint tersedia di:

http://localhost:8000/v1
Enter fullscreen mode Exit fullscreen mode

Gunakan vLLM saat Anda membutuhkan:

  • banyak request bersamaan,
  • server GPU bersama,
  • throughput tinggi,
  • deployment internal untuk beberapa developer atau service.

vLLM membutuhkan GPU CUDA atau hardware AMD ROCm terbaru. Ini bukan pilihan utama untuk Apple Silicon, tetapi cocok untuk cluster development atau environment server.

3. llama.cpp

llama.cpp adalah runtime C++ yang mendukung banyak platform, dari perangkat kecil hingga rig GPU besar. Server llama-server dapat mengekspos endpoint kompatibel OpenAI.

llama.cpp

Build dan jalankan:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j LLAMA_METAL=1

./llama-server -m models/llama-3.3-70b-q4_k_m.gguf \
  --port 8080 \
  --host 0.0.0.0 \
  -c 8192 \
  -ngl 99
Enter fullscreen mode Exit fullscreen mode

Flag penting:

-ngl 99
Enter fullscreen mode Exit fullscreen mode

Flag ini mengalihkan layer model ke GPU sebanyak mungkin. llama.cpp cocok jika Anda perlu:

  • mengontrol kuantisasi secara detail,
  • menjalankan model di hardware terbatas,
  • mengoptimalkan penggunaan VRAM,
  • menguji model GGUF spesifik.

LM Studio dan Jan membungkus llama.cpp dalam GUI dan juga dapat mengekspos endpoint OpenAI-compatible. Keduanya berguna untuk anggota tim non-teknis yang ingin menguji prompt tanpa terminal.

Verifikasi endpoint dengan Python

Setelah runtime berjalan, pastikan kontrak OpenAI-compatible bekerja.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",
)

resp = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[
        {
            "role": "user",
            "content": "Reply with the word OK only."
        }
    ],
)

print(resp.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Jika output adalah:

OK
Enter fullscreen mode Exit fullscreen mode

maka runtime, port, model, dan SDK sudah cocok.

Uji LLM lokal dengan Apidog

API LLM lokal hanya berguna jika rangkaian pengujian Anda dapat memanggilnya dengan cara yang sama seperti produksi. Di Apidog, gunakan environment variable agar satu project dapat menjalankan request ke target lokal dan hosted.

Apidog local LLM testing

Langkah 1: Buat environment Local

Di Apidog, buat environment baru bernama:

Local
Enter fullscreen mode Exit fullscreen mode

Tambahkan variable:

BASE_URL=http://localhost:11434/v1
API_KEY=ollama
Enter fullscreen mode Exit fullscreen mode

Langkah 2: Buat environment Production

Kloning environment OpenAI yang sudah ada atau buat baru:

BASE_URL=https://api.openai.com/v1
API_KEY=<OPENAI_API_KEY_ANDA>
Enter fullscreen mode Exit fullscreen mode

Langkah 3: Ubah request agar memakai variable

Gunakan URL:

{{BASE_URL}}/chat/completions
Enter fullscreen mode Exit fullscreen mode

Tambahkan header:

Authorization: Bearer {{API_KEY}}
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

Body contoh:

{
  "model": "llama3.3:70b-instruct-q4_K_M",
  "messages": [
    {
      "role": "system",
      "content": "You are a JSON-only assistant."
    },
    {
      "role": "user",
      "content": "Return {\"status\":\"ok\"}."
    }
  ],
  "response_format": {
    "type": "json_object"
  }
}
Enter fullscreen mode Exit fullscreen mode

Langkah 4: Tambahkan assertion

Buat skenario pengujian yang memeriksa bentuk respons.

Contoh assertion yang perlu dicek:

choices[0].message.role == "assistant"
choices[0].message.content tidak kosong
usage.total_tokens > 0
Enter fullscreen mode Exit fullscreen mode

Skenario ini berfungsi sebagai smoke test untuk runtime lokal dan endpoint hosted.

Langkah 5: Jalankan terhadap dua environment

Jalankan skenario terhadap:

Local
Enter fullscreen mode Exit fullscreen mode

Lalu ubah dropdown environment ke:

Production
Enter fullscreen mode Exit fullscreen mode

Jalankan lagi. Assertion harus hijau di kedua target.

Pola yang sama dapat diperluas ke pengujian agen AI yang memanggil API multi-langkah.

Switching target dari kode aplikasi

Python

Gunakan environment variable agar aplikasi tidak melakukan hardcoding endpoint.

import os
from openai import OpenAI

def get_client():
    if os.getenv("ENV") == "local":
        return OpenAI(
            base_url="http://localhost:11434/v1",
            api_key="ollama",
        )

    return OpenAI(
        api_key=os.environ["OPENAI_API_KEY"]
    )

client = get_client()

response = client.chat.completions.create(
    model=os.getenv("MODEL", "llama3.3:70b-instruct-q4_K_M"),
    messages=[
        {
            "role": "system",
            "content": "You are a JSON-only assistant."
        },
        {
            "role": "user",
            "content": "Return {\"status\": \"ok\"}."
        },
    ],
    response_format={
        "type": "json_object"
    },
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Jalankan lokal:

ENV=local MODEL=llama3.3:70b-instruct-q4_K_M python app.py
Enter fullscreen mode Exit fullscreen mode

Jalankan hosted:

ENV=production OPENAI_API_KEY=sk-... MODEL=gpt-... python app.py
Enter fullscreen mode Exit fullscreen mode

JavaScript 

import OpenAI from "openai";

const isLocal = process.env.ENV === "local";

const client = new OpenAI({
  baseURL: isLocal
    ? "http://localhost:11434/v1"
    : "https://api.openai.com/v1",
  apiKey: isLocal
    ? "ollama"
    : process.env.OPENAI_API_KEY,
});

const resp = await client.chat.completions.create({
  model: process.env.MODEL || "llama3.3:70b-instruct-q4_K_M",
  messages: [
    {
      role: "user",
      content: "Say hi.",
    },
  ],
});

console.log(resp.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

Jalankan lokal:

ENV=local MODEL=llama3.3:70b-instruct-q4_K_M node app.js
Enter fullscreen mode Exit fullscreen mode

Integrasi ke CI

Gunakan skenario Apidog sebagai regression test untuk memastikan kontrak respons tidak berubah saat:

  • model diganti,
  • tag model diperbarui,
  • runtime diperbarui,
  • endpoint hosted berubah,
  • konfigurasi prompt diubah.

Alur CI yang disarankan:

  1. Start runtime lokal.
  2. Pull model yang dibutuhkan.
  3. Jalankan koleksi atau skenario Apidog.
  4. Gagalkan build jika assertion gagal.

Contoh struktur GitHub Actions:

name: LLM API Smoke Test

on:
  pull_request:
  push:
    branches:
      - main

jobs:
  test-llm-api:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Start Ollama
        run: |
          curl -fsSL https://ollama.com/install.sh | sh
          ollama serve &
          sleep 5
          ollama pull llama3.3:70b-instruct-q4_K_M

      - name: Run API tests
        run: |
          apidog run ./apidog-collection.json --env Local
Enter fullscreen mode Exit fullscreen mode

Runner Apidog mengembalikan exit code non-nol saat assertion gagal, sehingga build otomatis berhenti. QA engineer dapat memasukkan pola ini ke pipeline pengujian API yang sudah ada.

Teknik lanjutan dan tips praktis

Pilih kuantisasi yang sesuai

Kuantisasi menentukan apakah model besar dapat dimuat di laptop. Format GGUF menyimpan bobot pada 8, 6, 5, 4, 3, atau 2 bit per parameter.

Panduan praktis:

Format Kapan dipakai
Q8 Kualitas lebih tinggi, cocok untuk coding, butuh RAM lebih besar
Q5_K_M Kompromi bagus jika RAM cukup
Q4_K_M Default praktis untuk chat dan development lokal
Q2_K Hemat memori, tetapi kualitas turun lebih terasa

Q4_K_M sering menjadi pilihan awal karena ukuran model jauh lebih kecil dibanding FP16, dengan penurunan kualitas yang masih dapat diterima untuk banyak tugas chat.

Maksimalkan GPU offload

Di llama.cpp, gunakan:

-ngl 99
Enter fullscreen mode Exit fullscreen mode

Di Ollama, gunakan opsi GPU yang sesuai konfigurasi model.

Prinsipnya sederhana: pindahkan sebanyak mungkin layer transformer ke GPU selama VRAM cukup. Layer yang kembali ke CPU biasanya menurunkan throughput secara signifikan.

Biarkan mmap aktif

mmap aktif secara default di llama.cpp dan Ollama. Ini memungkinkan OS memuat bobot sesuai kebutuhan, bukan mengalokasikan seluruh model saat startup.

Matikan hanya jika Anda benar-benar perlu mengontrol alokasi memori secara manual, misalnya di container dengan limit ketat.

Gunakan batching untuk vLLM

vLLM unggul saat menangani banyak request bersamaan. Untuk server bersama, konfigurasi seperti ini dapat membantu:

vllm serve meta-llama/Llama-3.3-70B-Instruct \
  --max-num-seqs 256 \
  --gpu-memory-utilization 0.9
Enter fullscreen mode Exit fullscreen mode

Untuk mesin yang lebih kecil, gunakan nilai lebih rendah:

--max-num-seqs 64
Enter fullscreen mode Exit fullscreen mode

Aktifkan streaming

Streaming mengurangi latensi yang dirasakan karena token dikirim saat dihasilkan.

Python:

stream = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[
        {"role": "user", "content": "Explain local LLM APIs briefly."}
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="")
Enter fullscreen mode Exit fullscreen mode

JavaScript:

const stream = await client.chat.completions.create({
  model: "llama3.3:70b-instruct-q4_K_M",
  messages: [
    {
      role: "user",
      content: "Explain local LLM APIs briefly.",
    },
  ],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}
Enter fullscreen mode Exit fullscreen mode

Gunakan Modelfile di Ollama

Modelfile membantu memindahkan prompt sistem, temperature, dan stop sequence dari kode aplikasi ke konfigurasi model.

Contoh:

FROM llama3.3:70b-instruct-q4_K_M

SYSTEM """
You are a JSON-only assistant.
Always return valid JSON.
"""

PARAMETER temperature 0.2
PARAMETER stop "</json>"
Enter fullscreen mode Exit fullscreen mode

Buat model baru:

ollama create my-assistant -f Modelfile
Enter fullscreen mode Exit fullscreen mode

Lalu panggil dari aplikasi:

response = client.chat.completions.create(
    model="my-assistant",
    messages=[
        {"role": "user", "content": "Return status ok."}
    ],
)
Enter fullscreen mode Exit fullscreen mode

Kesalahan umum

Hindari pola berikut saat mengintegrasikan LLM lokal.

1. Hardcoding endpoint lokal

Jangan lakukan ini:

base_url = "http://localhost:11434/v1"
Enter fullscreen mode Exit fullscreen mode

Gunakan environment variable:

base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
Enter fullscreen mode Exit fullscreen mode

2. Lupa membatasi output

Model lokal dapat menghasilkan output panjang jika tidak dibatasi. Selalu set:

{
  "max_tokens": 512
}
Enter fullscreen mode Exit fullscreen mode

atau gunakan stop sequence jika format output sudah jelas.

3. Port bentrok

Ollama biasanya memakai:

11434
Enter fullscreen mode Exit fullscreen mode

vLLM biasanya memakai:

8000
Enter fullscreen mode Exit fullscreen mode

llama.cpp memakai port yang Anda tentukan. Pastikan tidak ada dua runtime yang memakai port sama.

4. Mengabaikan header Authorization

Ollama dapat mengabaikan API key, tetapi vLLM dengan --api-key akan menolak request tanpa header:

Authorization: Bearer <key>
Enter fullscreen mode Exit fullscreen mode

Tetap kirim header ini agar request template Anda konsisten di lokal dan hosted.

5. Mengharapkan kualitas hosted dari model kecil atau terlalu terkuantisasi

Kuantisasi membantu memori, tetapi dapat menurunkan kemampuan reasoning, terutama untuk matematika, coding kompleks, dan konteks panjang.

Lokal vs hosted: biaya dan latensi

Angka berikut mengasumsikan M3 Max dengan memori terpadu 128 GB untuk lokal, serta harga publik endpoint hosted. Waktu token pertama atau TTFT diukur pada prompt 1.024 token, kondisi dingin, tanpa batching.

Model TTFT Lokal Throughput Lokal Setara Hosted Harga Hosted TTFT Hosted
Llama 3.3 70B Q4_K_M 1.2 dtk 12 tok/dtk GPT-5.5 Instant $5 / $30 per 1 Juta 200 ms
DeepSeek V4 67B Q4_K_M 1.4 dtk 10 tok/dtk DeepSeek-Chat hosted $0.55 / $2.20 per 1 Juta 280 ms
Qwen 3.6 32B Q5_K_M 0.7 dtk 28 tok/dtk Qwen-Max hosted $1.60 / $6.40 per 1 Juta 240 ms
Gemma 4 27B Q4_K_M 0.5 dtk 35 tok/dtk Gemini 3 Flash $0.35 / $1.05 per 1 Juta 180 ms

Interpretasi praktis:

  • Hosted unggul untuk latensi pengguna akhir.
  • Lokal unggul untuk development, privasi, dan biaya saat volume token tinggi.
  • Staging sebaiknya tetap menguji hosted agar perilaku produksi tervalidasi.
  • CI sebaiknya menjaga kedua target tetap hijau.

Pola yang paling aman:

Development -> Local
Staging     -> Hosted
CI          -> Local + Hosted smoke test
Production  -> Hosted atau private deployment
Enter fullscreen mode Exit fullscreen mode

Untuk benchmark model spesifik, lihat Cara menjalankan DeepSeek V4 secara lokal dan panduan penggunaan DeepSeek V4.

Kasus penggunaan dunia nyata

Fintech dan data sensitif

Tim kepatuhan fintech di Singapura dapat memakai Ollama di laptop engineer untuk menyusun laporan aktivitas mencurigakan. Prompt berisi nomor rekening dan pola transaksi yang tidak boleh keluar dari yurisdiksi tertentu. Endpoint hosted hanya menerima versi prompt yang sudah disunting.

Skenario Apidog dapat menegaskan bahwa redactor selalu berjalan sebelum request meninggalkan localhost.

Studio game dan prompt engineering

Studio game dapat melatih desainer menggunakan Qwen lokal. Workflow ini gratis, offline, dan mengurangi risiko lore game bocor ke pihak ketiga.

Saat masuk produksi, aplikasi bisa diarahkan ke Gemini 3 Flash dengan perubahan environment variable. Untuk koneksi produksi, lihat panduan API Gemini 3 Flash.

Healthcare dan private deployment

Startup healthcare dapat menjalankan vLLM pada GPU di dalam jaringan rumah sakit pelanggan. Endpoint tidak perlu muncul di DNS publik. Integration test berjalan dari Jenkins agent di VLAN yang sama, tetap menggunakan SDK OpenAI yang sama.

Hasilnya:

local laptop -> Ollama
hospital network -> vLLM
production hosted -> OpenAI-compatible API
Enter fullscreen mode Exit fullscreen mode

Satu kode klien. Tiga target deployment. Satu rangkaian skenario test.

Kesimpulan

LLM lokal sudah cukup matang untuk masuk ke workflow developer API. Anda dapat memindahkan prompt dari endpoint hosted ke endpoint lokal tanpa menulis ulang klien, test, atau CI.

Checklist implementasi:

  • Pilih Ollama untuk laptop.
  • Pilih vLLM untuk server GPU bersama.
  • Pilih llama.cpp untuk kontrol memori dan kuantisasi.
  • Ekspos endpoint OpenAI-compatible.
  • Verifikasi dengan curl atau SDK OpenAI.
  • Pindahkan base_url dan api_key ke environment variable.
  • Buat skenario di Apidog yang berjalan terhadap lokal dan hosted.
  • Bandingkan biaya, latensi, dan kualitas output per workload.

Mulai dari endpoint lokal seperti:

http://localhost:11434/v1
Enter fullscreen mode Exit fullscreen mode

lalu jalankan skenario yang sama terhadap:

https://api.openai.com/v1
Enter fullscreen mode Exit fullscreen mode

Jika Anda belum memilih model, mulai dari LLM Lokal Terbaik 2026. Jika Anda ingin menguji alur agensial yang memanggil banyak API, baca Cara menguji API agen AI.

Top comments (0)