devbox.id

Developer tools, self-hosted dev environments, productivity for solo engineers

Jalankan AI Coding Assistant Lokal dengan Ollama

by Marcus Chen
Jalankan AI Coding Assistant Lokal dengan Ollama

Masalah: AI Coding Assistant yang Makan Dompet

Kamu udah nyoba GitHub Copilot, terus tagihan kartu kredit datang. Atau kamu pakai GPT-4 API langsung dari editor, dan tiba-tiba $40 habis dalam seminggu karena lupa matiin context yang panjang. Belum lagi soal privasi — setiap snippet kode yang kamu ketik dikirim ke server orang lain.

Solusinya: jalanin model AI sendiri di laptop atau VPS kamu, sambungkan ke editor, dan lupakan API key selamanya.

Artikel ini akan setup Ollama sebagai local model runner, lalu sambungkan ke VS Code pakai extension Continue.dev. Hasilnya: AI coding assistant yang jalan offline, gratis, dan data kamu tetap di mesin kamu sendiri.

Kenapa Ollama?

Ada beberapa tool untuk jalanin LLM lokal — llama.cpp, LM Studio, Jan.ai. Tapi Ollama punya keunggulan buat developer:

  • API-compatible dengan OpenAI — banyak tool langsung bisa connect tanpa modifikasi
  • CLI yang bersih — ollama run codellama dan langsung jalan
  • Model library yang gede — Llama 3, Mistral, CodeLlama, Qwen2.5-Coder, semuanya satu perintah
  • Cross-platform — macOS, Linux, Windows (via WSL2)

Gotcha pertama yang gue temuin: Ollama di Linux defaultnya hanya listen di 127.0.0.1:11434. Kalau kamu mau akses dari mesin lain (misalnya VS Code di laptop, model di VPS), kamu perlu set environment variable OLLAMA_HOST=0.0.0.0:11434 sebelum jalanin service-nya.

Install Ollama

macOS / Linux

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

Setelah install, cek apakah service sudah jalan:

ollama --version
# ollama version is 0.3.x

curl http://localhost:11434
# Ollama is running

Linux sebagai systemd service (supaya auto-start)

Kalau install via script di atas, Ollama otomatis terdaftar sebagai systemd service. Tapi kalau mau expose ke jaringan lokal:

sudo systemctl edit ollama

Tambahkan ini di dalam block [Service]:

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"

Lalu restart:

sudo systemctl daemon-reload
sudo systemctl restart ollama

Pilih Model yang Tepat

Ini bagian paling penting dan paling sering salah. Jangan langsung pull model 70B karena "katanya lebih bagus" — kalau RAM kamu cuma 16GB, model bakal swap ke disk dan inference-nya lambat banget.

Patokan kasar:

RAM Tersedia Model yang Realistis
8 GB 7B (quantized Q4)
16 GB 13B atau 7B full
32 GB+ 34B, bisa coba 70B Q4

Buat coding assistant, dua model yang gue rekomendasikan:

Qwen2.5-Coder:7b — bagus untuk code completion dan chat, context window 128K, ringan:

ollama pull qwen2.5-coder:7b

DeepSeek-Coder-V2:16b — kalau RAM kamu 16GB+, ini lebih kuat untuk reasoning dan refactoring:

ollama pull deepseek-coder-v2:16b

Test dulu via CLI sebelum lanjut:

ollama run qwen2.5-coder:7b
>>> Write a Python function to parse JWT without library

Kalau response-nya masuk akal dan cepat (< 5 detik untuk token pertama), lanjut ke langkah berikutnya.

Setup Continue.dev di VS Code

Continue.dev adalah extension open-source yang nyambungin VS Code (dan JetBrains) ke berbagai LLM backend — termasuk Ollama.

Install extension

Buka VS Code, pergi ke Extensions (Ctrl+Shift+X), cari Continue, install yang dari continue.dev.

Atau via CLI:

code --install-extension Continue.continue

Setelah install, akan muncul icon Continue di sidebar kiri. Klik, lalu pilih Add Model.

Konfigurasi manual via config.json

Cara yang lebih reliable: edit config langsung. Tekan Ctrl+Shift+P, ketik Continue: Open config.json.

Ganti atau tambahkan block models dan tabAutocompleteModel:

{
  "models": [
    {
      "title": "Qwen2.5 Coder 7B",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b",
      "apiBase": "http://localhost:11434"
    },
    {
      "title": "DeepSeek Coder V2 16B",
      "provider": "ollama",
      "model": "deepseek-coder-v2:16b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen2.5 Coder 7B (Autocomplete)",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b",
    "apiBase": "http://localhost:11434"
  },
  "allowAnonymousTelemetry": false
}

Simpan file. Continue akan auto-reload konfigurasi.

Tes koneksi

Buka file Python atau JavaScript apapun, highlight beberapa baris kode, tekan Ctrl+L untuk buka chat, ketik:

Jelaskan apa yang dilakukan kode ini

Kalau Ollama jalan dan model sudah di-pull, response akan muncul dalam beberapa detik.

Workflow Sehari-hari yang Gue Pakai

Sekarang bagian yang bikin setup ini worth it.

1. Inline chat untuk refactoring

Highlight fungsi yang mau direfactor → Ctrl+L → ketik instruksi:

Refactor ini supaya handle error dengan proper, tambah type hints, dan pisahin logic validasi ke fungsi terpisah

Continue akan tampilkan diff yang bisa kamu accept atau reject per-blok. Ini jauh lebih berguna daripada copy-paste ke ChatGPT.

2. Tab autocomplete

Ini jalan otomatis di background. Saat kamu ngetik, Continue kirim context ke Ollama dan suggest completion. Tekan Tab untuk accept.

Gotcha: autocomplete bisa bikin CPU/GPU kamu kerja terus kalau kamu ngetik lambat. Kalau laptop kamu panas atau fan berisik, kamu bisa disable autocomplete dan pakai manual chat aja:

{
  "tabAutocompleteOptions": {
    "disable": true
  }
}

3. Slash commands untuk task berulang

Continue punya built-in slash commands. Yang paling sering gue pakai:

  • /edit — edit file langsung dari chat
  • /comment — generate docstring untuk fungsi yang di-highlight
  • /test — generate unit test
  • /share — export conversation jadi markdown

Contoh:

/test buatkan pytest untuk fungsi parse_invoice ini, cover edge case input kosong dan format salah

4. Tambah context dengan @-mentions

Kamu bisa mention file atau folder spesifik sebagai context:

@models/user.py @routes/auth.py
Kenapa login endpoint bisa return 200 tapi session tidak tersimpan?

Ini berguna banget waktu debugging bug yang melibatkan beberapa file sekaligus.

Gotcha yang Perlu Kamu Tahu

1. Model pertama kali load itu lambat Ollama load model ke memory saat request pertama. Bisa 10–30 detik. Setelah itu fast. Kalau kamu mau pre-load model supaya selalu ready:

# Kirim request kosong untuk "warm up" model
curl http://localhost:11434/api/generate -d '{"model": "qwen2.5-coder:7b", "prompt": "", "keep_alive": -1}'

Flag keep_alive: -1 bikin model tetap di memory sampai Ollama di-restart.

2. Context window vs RAM Model dengan context 128K bukan berarti kamu bisa kirim 128K token tanpa konsekuensi. Semakin panjang context, semakin banyak RAM yang dipakai saat inference. Kalau kamu kirim seluruh codebase sebagai context, model bisa OOM.

3. Quantization matters Saat pull model, perhatikan tag-nya. qwen2.5-coder:7b defaultnya Q4_K_M. Kalau mau lebih akurat (tapi lebih berat), pull qwen2.5-coder:7b-fp16. Kalau RAM terbatas, cari yang Q3 atau Q2 — tapi kualitas turun signifikan.

4. Continue.dev vs Copilot UX Continue masih kalah polish dibanding Copilot untuk autocomplete. Kadang suggestion muncul terlambat, atau context yang diambil kurang tepat. Ini trade-off yang harus kamu terima untuk setup lokal.

Langkah Lanjutan

Setup di atas sudah cukup buat daily coding. Tapi kalau kamu mau push lebih jauh:

Akses dari remote (laptop ke VPS)

Kalau model jalan di VPS dan kamu coding di laptop, ubah apiBase di config.json:

"apiBase": "http://your-vps-ip:11434"

Pastikan firewall VPS-mu allow port 11434, atau lebih aman: tunnel via SSH:

ssh -L 11434:localhost:11434 user@your-vps-ip

Lalu apiBase tetap http://localhost:11434 di laptop kamu.

Coba model lain untuk task spesifik

Ollama bisa jalankan beberapa model sekaligus (bergantian, bukan paralel). Kamu bisa set model berbeda untuk chat vs autocomplete:

  • Chat/reasoning: deepseek-coder-v2:16b atau llama3.1:8b
  • Autocomplete (harus cepat): qwen2.5-coder:1.5b atau starcoder2:3b

Integrasikan dengan tool lain

Karena Ollama expose OpenAI-compatible API di http://localhost:11434/v1, kamu bisa pakai library openai Python langsung:

from openai import OpenAI

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

response = client.chat.completions.create(
    model="qwen2.5-coder:7b",
    messages=[
        {"role": "user", "content": "Review kode ini dan kasih saran perbaikan: def calc(x,y): return x/y"}
    ]
)

print(response.choices[0].message.content)

Ini berguna kalau kamu mau build automation — misalnya script yang auto-review PR sebelum di-push, atau generate changelog dari git log.

Yang Gue Lakuin Sekarang

Setelah setup ini jalan, gue stop bayar Copilot. Untuk solo project dan side project, Qwen2.5-Coder:7b sudah lebih dari cukup — code completion-nya solid, dan response untuk refactoring request cukup akurat.

Satu hal yang masih gue pakai cloud AI: task yang butuh reasoning sangat dalam atau knowledge yang sangat spesifik (misalnya debugging race condition yang aneh). Untuk itu gue buka Claude.ai manual — bukan dari editor.

Tapi untuk 80% pekerjaan coding sehari-hari — autocomplete, explain code, generate boilerplate, tulis test — setup lokal ini sudah handle dengan baik.

Coba pull qwen2.5-coder:7b sekarang, sambungkan ke Continue.dev, dan lihat sendiri apakah worth it buat workflow kamu.