Jalankan LLM Lokal dengan Ollama: Instalasi, Model, dan API OpenAI-Compatible

Kamu butuh endpoint LLM buat aplikasi, tapi nggak mau kirim semua pesan user ke pihak ketiga, dan tagihan per-token cepat membengkak pas lagi iterasi. Ollama jawab dua-duanya: dia jalanin model open di mesin kamu sendiri dan expose lewat API yang ngomong pakai protokol OpenAI, jadi sebagian besar kode yang ada cuma perlu ganti base_url.

Ini panduan hands-on: instalasi, milih model yang muat di RAM, chat lewat CLI dan REST, arahin OpenAI SDK client ke dia, kustomisasi model pakai Modelfile, dan bikin embedding buat RAG. Semua command di bawah cocok sama dokumentasi resmi terkini (Ollama v0.33.x, September 2026).

Prerequisites

• Mesin Linux, macOS, atau Windows (command di bawah fokus ke Linux; Windows alurnya sama cuma installer-nya PowerShell)
• RAM: 8GB itu batas realistis buat model 7B, 16GB buat 13B
• Disk: 3-50GB tergantung model (ukuran ada di tabel bawah)
• Docker opsional, kalau kamu lebih suka container

Langkah 1: Instalasi

Linux dan macOS:

curl -fsSL https://ollama.com/install.sh | sh

Windows PowerShell:

irm https://ollama.com/install.ps1 | iex

Cek hasilnya:

ollama --version

Atau jalanin lewat Docker:

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Buat GPU NVIDIA di Docker kamu juga perlu NVIDIA Container Toolkit, terus tambah --gpus=all ke command run. GPU AMD pakai tag :rocm. Di Linux installer-nya mendaftarkan service systemd, dan Ollama dengerin di 127.0.0.1:11434 secara default.

Langkah 2: Pull dan jalanin model

Satu command udah cukup buat mulai ngobrol:

ollama run llama3.2

Ini narik model 3B (~2.0GB) dan buka REPL. Ketik /bye buat keluar. Di dalam REPL kamu bisa ganti parameter langsung, misalnya ukuran konteks:

/set parameter num_ctx 8192

Buat download tanpa chat, pakai ollama pull. Pilihan populer berdasarkan ukuran (ukuran download dan context window dari Ollama library, September 2026):

Model	Download	Context	RAM dibutuhkan	Cocok buat
qwen2.5:0.5b	398MB	32K	~2GB	tes cepat, CPU kelas bawah
llama3.2:1b	1.3GB	128K	~4GB	mesin kecil
llama3.2 (3B)	2.0GB	128K	~8GB	pilihan default, chat umum
qwen2.5 (7B)	4.7GB	32K	8-16GB	kualitas lebih kuat, multibahasa
qwen2.5:14b-instruct-q4_0	8.5GB	32K	~16GB	workload lokal yang lebih berat
qwen2.5:72b	47GB	32K	~64GB	batas paling realistis

Dokumentasi Ollama terus terang soal memory: model 7B butuh minimal 8GB RAM, 13B butuh 16GB, 33B butuh 32GB. Bonus buat pembaca Indonesia: keluarga Qwen memang kuat di Bahasa Indonesia, penting kalau project kamu melayani pasar sini.

Cek apa yang udah punya:

ollama list          # model yang sudah di-pull
ollama ps            # yang lagi dimuat sekarang, dan jalan di mana

ollama ps nampilin kolom PROCESSOR: 100% GPU, 100% CPU, atau split kayak 48%/52% CPU/GPU. Satu command ini langsung jawab pertanyaan "kenapa lambat sih".

Langkah 3: Chat lewat REST API

Ollama jalanin HTTP server di 127.0.0.1:11434. Endpoint native: /api/chat buat percakapan, /api/generate buat satu prompt, /api/embed buat embedding.

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    { "role": "user", "content": "Why is the sky blue?" }
  ],
  "stream": false
}'

stream: false bikin curl nunggu jawaban lengkap, bukan aliran token. Lebih gampang dibaca pertama kali.

Client resmi bungkus API ini. Python:

pip install ollama

from ollama import chat

response = chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Why is the sky blue?'}],
)
print(response.message.content)

JavaScript:

npm i ollama

import ollama from 'ollama';

const response = await ollama.chat({
  model: 'llama3.2',
  messages: [{ role: 'user', content: 'Why is the sky blue?' }],
});
console.log(response.message.content);

Langkah 4: API OpenAI-compatible, bagian yang paling kepake

Ollama mengimplementasi sebagian API OpenAI di bawah /v1: /v1/chat/completions, /v1/completions, /v1/models, /v1/embeddings, dan sejak v0.13.3 juga /v1/responses. Arahin client OpenAI mana pun ke dia, dan kode yang udah ada kebanyakan langsung jalan:

curl http://localhost:11434/v1/chat/completions   -H "Content-Type: application/json"   -d '{
    "model": "llama3.2",
    "messages": [{ "role": "user", "content": "Hello!" }]
  }'

Pakai package openai standar di Python:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # nilai apa pun jalan; nggak ada auth di lokal
)

resp = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Summarize this in one line: ..."}],
)
print(resp.choices[0].message.content)

Baris api_key itu sering bikin bingung: Ollama nggak ngecek dia di lokal, tapi SDK-nya wajib ada field itu. String apa pun boleh.

Yang didukung di /v1/chat/completions: streaming, JSON mode lewat response_format, output yang bisa direproduksi lewat seed, vision, tools (function calling), logprobs, dan kontrol reasoning buat model berpikir.

Catatan:

• Protokol OpenAI nggak punya field buat ukuran konteks. Buat nambahnya, bikin Modelfile (Langkah 5) atau set OLLAMA_CONTEXT_LENGTH.
• Kalau ada tool yang hardcode nama model kayak gpt-3.5-turbo, salin model kamu ke nama itu:

ollama cp llama3.2 gpt-3.5-turbo

• /v1/responses jalan, tapi cuma versi stateless: previous_response_id dan conversation nggak didukung.

Langkah 5: Kustomisasi model dengan Modelfile

Modelfile itu Dockerfile-nya model. Kasus paling umum: kunci system prompt dan parameter sampling biar perilaku model nggak melenceng antar panggilan.

FROM llama3.2
PARAMETER temperature 0.7
PARAMETER num_ctx 8192
PARAMETER top_k 40
SYSTEM Kamu asisten teknis berbahasa Indonesia. Jawab ringkas, tanpa basa-basi.

Build dan jalanin:

ollama create asisten-teknis -f ./Modelfile
ollama run asisten-teknis

Parameter yang perlu diketahui: temperature (default 0.8), top_p (0.9), top_k (40), min_p, num_predict, seed, stop. Naikin num_ctx kalau prompt kamu panjang; konteks makan RAM, jadi 8192 itu default yang masuk akal buat kebanyakan setup lokal. MESSAGE buat nyuntik contoh riwayat percakapan.

ollama show --modelfile llama3.2 nampilin blueprint lengkap model mana pun. Ini cara tercepat buat belajar template persis yang diharapkan sebuah model.

Langkah 6: Embedding buat RAG

Buat workflow retrieval, pull model embedding:

ollama pull nomic-embed-text   # 274MB

Embed lewat endpoint native:

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "The sky is blue because of Rayleigh scattering"
}'

Model yang sama jalan lewat /v1/embeddings yang OpenAI-compatible, artinya retriever gaya LangChain bisa pakai dia tanpa lem manual. Vector itu langsung cocok masuk ke pgvector atau Qdrant kalau kamu lagi bangun RAG.

Langkah 7: Pengaturan server yang penting

Tiga environment variable paling berpengaruh begitu ini nggak cuma mainan:

• OLLAMA_HOST: server cuma dengerin 127.0.0.1 secara default. Biar bisa diakses dari mesin lain di LAN:

sudo systemctl edit ollama
# tambah di bawah [Service]:
Environment="OLLAMA_HOST=0.0.0.0:11434"
sudo systemctl daemon-reload && sudo systemctl restart ollama

• OLLAMA_MODELS: lokasi penyimpanan model (default Linux: /usr/share/ollama/.ollama/models). Pindahin kalau disk root kamu mepet.
• OLLAMA_CONTEXT_LENGTH: default context window buat model yang nggak set sendiri. Naikin, siap-siap RAM melonjak.

Perilaku memory: model di-unload setelah 5 menit idle secara default. Buat aplikasi yang terus nge-hit API, kirim keep_alive: -1 di request biar model tetap nempel, atau ollama stop <model> buat unload langsung. Preload model pakai request kosong biar user pertama nggak kena cold start.

Flash attention (OLLAMA_FLASH_ATTENTION=1) dan KV cache terkuantisasi (OLLAMA_KV_CACHE_TYPE=q8_0) motong pemakaian memory pas konteks makin panjang; q8_0 cuma makan sekitar separuh memory f16 dengan penurunan kualitas yang nyaris nggak kerasa.

Keamanan: nggak ada autentikasi secara default. Bind OLLAMA_HOST=0.0.0.0 terus expose port 11434 ke internet tanpa reverse proxy dan auth di depannya itu ide yang buruk.

Kapan pakai Ollama dibanding alternatif

Ollama pilihan yang tepat kalau kamu mau jalur tercepat dari nol ke API model lokal, butuh kompatibilitas protokol OpenAI biar client yang ada tetap jalan, atau kamu di satu mesin / tim kecil.

• llama.cpp itu inference engine yang jadi dasar Ollama. Pakai langsung kalau kamu perlu compile dari source atau mau ngorek performa dari hardware yang nggak biasa. Ollama itu llama.cpp plus manajemen model dan lapisan API.
• LM Studio ngasih pengalaman yang sama (model GGUF, server lokal) dengan fokus GUI yang lebih besar. Pilih Ollama kalau kamu mau workflow CLI-first yang bisa di-script.
• vLLM dibikin buat serving throughput tinggi model besar ke banyak user konkuren di server GPU, dengan continuous batching dan paged attention. Kebanyakan buat laptop, pas buat cluster inference produksi.
• Cloud API (OpenAI, Anthropic) ngasih model yang lebih kuat dan tanpa urusan hardware, tapi ada biaya per-token dan data kamu keluar dari mesin. Lokal dulu buat prototipe dan data sensitif; cloud kalau kualitas model terbesar lebih penting daripada tagihan.

Langkah selanjutnya

• Sambungin Ollama ke agent loop: /v1 mendukung function calling, jadi kode tool-use yang sudah ada jalan apa adanya.
• Bangun RAG pakai embedding lokal (Langkah 6) plus vector database buat retrieval.
• Baca FAQ sebelum expose server: setup proxy, ngrok, Cloudflare Tunnel, dan OLLAMA_ORIGINS buat ekstensi browser semuanya ada di sana.

Itu loop lengkapnya: install, pull, ganti base_url, beres. Model tinggal di disk kamu, API nongkrong di 11434, dan satu-satunya tagihan cuma listrik.

Referensi

• Repositori GitHub Ollama
• Dokumentasi OpenAI compatibility Ollama
• Referensi Modelfile Ollama
• FAQ Ollama: memory, environment variables, konfigurasi server