Menjalankan OpenCode dengan Ollama Remote: Qwen3-Coder 30B, Context 16K, dan Efisiensi Memory

adit

August 28, 2026

OpenCode semakin menarik digunakan sebagai coding agent ketika dipadukan dengan Ollama. Kombinasi ini memungkinkan proses pengembangan aplikasi dilakukan menggunakan model AI lokal tanpa harus mengirim source code ke layanan AI cloud.

Dalam konfigurasi yang saya gunakan, OpenCode berjalan di Mac, sedangkan Ollama ditempatkan di server terpisah dengan GPU NVIDIA RTX 3060 12 GB. Model yang digunakan adalah Qwen3-Coder 30B.

Konfigurasi ini menarik karena ukuran model lebih besar daripada kapasitas VRAM GPU. Model akhirnya berjalan menggunakan kombinasi GPU dan RAM melalui CPU/GPU offloading.

Artikel ini membahas konfigurasi tersebut, cara menghubungkan OpenCode ke Ollama remote, meningkatkan context window, memantau penggunaan memory, serta beberapa pertimbangan agar model tetap efisien.

Arsitektur OpenCode dan Ollama Remote

Pada konfigurasi ini, OpenCode tidak menjalankan model AI secara langsung di Mac.

Arsitekturnya adalah:

Mac
│
└── OpenCode
      │
      │ HTTP
      ▼
10.10.10.178:11434
      │
      └── Ollama
            │
            └── Qwen3-Coder 30B
                  │
                  ├── RTX 3060 12 GB
                  └── System RAM 23 GB

Dengan pendekatan ini, Mac hanya menjalankan OpenCode dan tools yang diperlukan. Beban inference model berada di server.

Keuntungan utamanya adalah komputer yang digunakan untuk coding tidak harus memiliki GPU besar. Selama server Ollama dapat diakses melalui jaringan, OpenCode dapat menggunakannya sebagai backend model.

Mengapa Menggunakan Qwen3-Coder 30B?

Untuk coding sederhana, model 7B atau 8B sebenarnya sudah cukup.

Namun ketika pekerjaan mulai kompleks, kebutuhan model juga meningkat.

Contohnya ketika meminta AI membangun aplikasi Laravel production-style dengan:

authentication
authorization
database migration
REST API
business logic
testing
Docker
validation
audit log
payment workflow
state machine

Model harus mampu mempertahankan banyak konteks sekaligus.

Karena itu saya memilih Qwen3-Coder 30B sebagai eksperimen untuk pekerjaan coding yang lebih kompleks.

Model ini memiliki sekitar 30B parameter dan memang ditujukan untuk software engineering dan agentic coding. Model Q4 yang tersedia di Ollama berukuran sekitar 19 GB, sehingga lebih besar daripada VRAM RTX 3060 12 GB.

RTX 3060 12 GB untuk Qwen3-Coder 30B

Di sinilah bagian yang menarik.

GPU yang digunakan:

NVIDIA GeForce RTX 3060
VRAM: 12 GB

Sementara ukuran model:

Qwen3-Coder 30B
≈ 19 GB

Model tidak mungkin seluruhnya dimuat ke VRAM 12 GB.

Ollama kemudian menggunakan CPU/GPU offloading.

Pada pengujian, ollama ps menunjukkan:

NAME               SIZE    PROCESSOR
qwen3-coder:30b    19 GB   43%/57% CPU/GPU

Artinya sebagian model ditempatkan di GPU dan sebagian lainnya menggunakan CPU/RAM.

Penting untuk dipahami bahwa angka tersebut bukan berarti 43 persen waktu inference menggunakan CPU dan 57 persen menggunakan GPU.

Lebih tepatnya, model dibagi menjadi bagian yang ditempatkan pada memory GPU dan memory sistem.

Secara sederhana:

Qwen3-Coder 30B
       │
       ├── GPU layers
       │     └── RTX 3060 VRAM
       │
       └── CPU layers
             └── System RAM

Apakah CPU/GPU Hybrid Membuat Model Tidak Bisa Digunakan?

Tidak.

Model tetap dapat digunakan oleh OpenCode.

Konsekuensinya terutama pada performa. GPU memiliki bandwidth memory yang jauh lebih tinggi dibandingkan akses memory sistem melalui CPU.

Karena sebagian model berada di RAM, inference akan lebih lambat dibandingkan model yang seluruhnya dapat dimuat di VRAM.

Namun jika prioritas utama adalah kualitas hasil coding, bukan latency, konfigurasi hybrid seperti ini tetap menarik.

Ini terutama berlaku untuk pekerjaan yang membutuhkan model bekerja cukup lama untuk menghasilkan dan memperbaiki kode.

Mengecek Penggunaan GPU dan Memory

Salah satu keuntungan menggunakan Ollama adalah kita dapat memantau model secara langsung.

Gunakan:

ollama ps

Untuk melakukan monitoring otomatis setiap satu detik:

watch -n 1 ollama ps

Output akan menunjukkan informasi seperti:

NAME               SIZE    PROCESSOR          CONTEXT
qwen3-coder:30b    19 GB   43%/57% CPU/GPU    8192

Untuk melihat penggunaan RAM:

watch -n 1 'free -h; echo; ollama ps'

Sedangkan untuk melihat penggunaan GPU secara langsung:

watch -n 1 nvidia-smi

Atau menggunakan monitoring NVIDIA secara lebih kontinu:

nvidia-smi dmon -s pucm -d 1

RAM 23 GB Masih Cukup?

Server yang digunakan memiliki:

RAM: 23 GiB
Swap: 8 GiB

Saat model dijalankan, kondisi memory yang diamati adalah sekitar:

RAM total       23 GiB
RAM available   sekitar 21 GiB
Swap used       sekitar 90 MiB

Ini merupakan kondisi yang cukup baik.

Hal yang paling penting adalah swap tidak digunakan secara signifikan.

Swap sebaiknya dianggap sebagai safety net, bukan memory utama untuk inference.

Jika inference mulai menggunakan beberapa gigabyte swap, performa dapat turun sangat drastis.

Karena itu, kombinasi:

RTX 3060 12 GB
+
RAM 23 GB

masih cukup menarik untuk menjalankan model sekitar 19–20 GB secara hybrid.

Menaikkan Context Window dari 8K ke 16K

Konfigurasi awal menggunakan:

CONTEXT = 8192

Untuk project kecil, 8K cukup.

Namun untuk coding agent, context lebih besar dapat membantu ketika model harus mempertahankan:

requirement
struktur project
file yang sudah dibuat
hasil command
error compiler
hasil testing
percakapan sebelumnya

Untuk itu context dinaikkan menjadi:

Model kemudian dibuat menggunakan Modelfile:

FROM qwen3-coder:30b

PARAMETER num_ctx 16384

Kemudian:

ollama create qwen3-coder:30b-16k -f ~/Modelfile-qwen3-coder

Setelah model dijalankan, ollama ps menunjukkan:

NAME                  SIZE    PROCESSOR          CONTEXT
qwen3-coder:30b-16k   20 GB   45%/55% CPU/GPU    16384

Perubahan yang terlihat:

8K Context

19 GB
43% CPU / 57% GPU
8192


16K Context

20 GB
45% CPU / 55% GPU
16384

Kenaikan ukuran model loaded hanya sekitar 1 GB pada pengujian tersebut.

Mengapa Tidak Langsung Menggunakan Context 32K?

Secara teori model dapat mendukung context yang sangat besar.

Tetapi context window bukan hanya masalah kemampuan model. Ada kebutuhan memory tambahan untuk KV cache.

Semakin besar context:

8K
 ↓
16K
 ↓
32K
 ↓
64K

semakin besar kebutuhan memory inference.

Dalam kasus RTX 3060 12 GB, model 30B saja sudah membutuhkan lebih banyak memory daripada VRAM yang tersedia.

Karena itu 16K menjadi kompromi yang masuk akal:

Qwen3-Coder 30B
+
16K context
+
GPU/CPU offloading

Daripada memaksakan context terlalu besar dan akhirnya meningkatkan tekanan terhadap RAM atau swap.

Konfigurasi OpenCode

Karena Ollama berada di server berbeda, OpenCode diarahkan ke endpoint Ollama melalui konfigurasi provider.

File konfigurasi global di macOS berada di:

~/.config/opencode/opencode.jsonc

Konfigurasi yang digunakan:

{
  "$schema": "https://opencode.ai/config.json",

  "model": "ollama/qwen3-coder:30b-16k",

  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama Remote - Qwen3 Coder 30B",
      "options": {
        "baseURL": "http://10.10.10.178:11434/v1"
      },
      "models": {
        "qwen3-coder:30b-16k": {
          "name": "Qwen3 Coder 30B 16K"
        }
      }
    }
  }
}

Dengan konfigurasi tersebut, OpenCode di Mac akan mengirim request ke:

http://10.10.10.178:11434/v1

bukan ke Ollama yang berjalan di Mac.

Cara Memastikan OpenCode Benar-Benar Menggunakan Ollama

Salah satu cara paling sederhana adalah melihat model melalui:

/models

Kemudian pilih:

ollama/qwen3-coder:30b-16k

Untuk verifikasi yang lebih kuat, buka terminal di server Ollama:

ollama ps

Kemudian jalankan task dari OpenCode.

Jika terlihat:

qwen3-coder:30b-16k

berarti request OpenCode memang sedang menggunakan model tersebut di server.

Pengujian Tool Calling

Hal penting ketika menggunakan OpenCode adalah model bukan hanya harus mampu menghasilkan kode.

Model juga harus mampu menggunakan tools.

Contohnya:

User
  ↓
OpenCode
  ↓
Qwen
  ↓
write_file
  ↓
OpenCode menulis file
  ↓
go test
  ↓
hasil dikembalikan ke Qwen
  ↓
Qwen memperbaiki kode

Dalam pengujian sebelumnya, Qwen3 8B berhasil mengembalikan native tool_calls.

Sebaliknya, Qwen2.5-Coder 14B yang diuji melalui endpoint Ollama mengembalikan instruksi tool sebagai JSON di dalam message.content.

Perbedaan ini penting karena OpenCode membutuhkan tool call yang dapat diproses sebagai tool, bukan sekadar teks yang terlihat seperti JSON.

Benchmark Coding yang Lebih Realistis

Untuk menguji apakah model benar-benar cocok untuk OpenCode, benchmark sederhana seperti Hello World tidak cukup.

Test yang lebih realistis adalah meminta model membangun aplikasi.

Contohnya aplikasi pencatatan hutang/piutang Laravel.

Business flow-nya:

User A
  │
  │ membuat hutang
  ▼
User B
  │
  │ konfirmasi
  ▼
ACTIVE
  │
  │ A melakukan pembayaran
  ▼
PAYMENT PENDING
  │
  │ B konfirmasi
  ▼
SETTLED

Dengan partial payment:

Hutang       Rp1.000.000

Pembayaran 1 Rp400.000
             ↓
Sisa         Rp600.000

Pembayaran 2 Rp600.000
             ↓
Sisa         Rp0

Status       SETTLED

Task seperti ini lebih baik untuk menguji kemampuan model karena membutuhkan pemahaman business logic, authorization, database transaction, state transition, testing, dan error handling.

Jangan Hanya Melihat Kode yang Dihasilkan

Untuk coding agent, kualitas tidak cukup dinilai dari apakah model menghasilkan banyak file.

Model yang bagus seharusnya melakukan siklus:

Requirement
    ↓
Planning
    ↓
Implementasi
    ↓
Run
    ↓
Error
    ↓
Diagnosis
    ↓
Fix
    ↓
Test
    ↓
Fix lagi jika diperlukan
    ↓
Build
    ↓
Verify

Ini jauh lebih penting daripada sekadar:

"Model berhasil membuat 30 file."

Sebab model bisa saja menghasilkan banyak kode tetapi dependency salah, migration rusak, authorization tidak ada, dan test sebenarnya tidak pernah dijalankan.

Efisiensi Memory untuk RTX 3060 12 GB

Untuk setup seperti ini, beberapa prinsip cukup penting.

1. Jangan memaksakan semua model ke GPU

Model 30B memang terlalu besar untuk VRAM 12 GB.

Biarkan Ollama melakukan CPU/GPU offloading.

2. Gunakan context sesuai kebutuhan

Untuk Qwen3-Coder 30B:

8K  → baseline
16K → rekomendasi
32K → eksperimen jika RAM mencukupi

Tidak selalu lebih besar berarti lebih baik.

Context besar memiliki biaya memory.

3. Hindari swap

Pantau:

free -h

Jika swap mulai naik secara signifikan saat inference, pertimbangkan menurunkan context atau menggunakan model yang lebih kecil.

4. Jangan keep-alive semua model

Ollama dapat mempertahankan model di memory, tetapi server dengan memory terbatas sebaiknya tidak memaksa banyak model tetap loaded.

Untuk workflow coding, mempertahankan satu model utama selama beberapa menit biasanya sudah cukup.

Bagaimana dengan Model 14B?

Menariknya, model 14B yang seluruhnya bisa berada di VRAM dapat memiliki latency yang lebih baik dibandingkan model 30B hybrid.

Misalnya:

Model 14B
↓
100% GPU
↓
lebih cepat

dibandingkan:

Model 30B
↓
GPU + CPU
↓
lebih lambat

Karena itu ada trade-off:

Konfigurasi	Kecepatan	Kapasitas model
8B full GPU	Tinggi	Lebih kecil
14B full GPU	Sedang–tinggi	Lebih besar
30B hybrid	Lebih lambat	Lebih besar

Untuk tujuan coding agent, pilihan terbaik harus ditentukan melalui workload nyata.

Jika prioritasnya adalah kode sebaik mungkin dan waktu bukan masalah, 30B hybrid layak dicoba.

Jika prioritasnya adalah interaktif dan cepat, 14B full GPU bisa lebih nyaman.

Kesimpulan

Dengan hardware:

RTX 3060 12 GB
RAM 23 GB

Qwen3-Coder 30B masih dapat digunakan melalui Ollama dengan CPU/GPU offloading.

Konfigurasi yang digunakan:

OpenCode
    ↓
Ollama Remote
    ↓
Qwen3-Coder 30B
    ↓
Context 16K
    ↓
RTX 3060 + RAM

Konfigurasi 30B + 16K context merupakan titik yang menarik untuk dicoba ketika kualitas coding lebih penting daripada kecepatan.

Namun jangan menilai keberhasilannya hanya dari ollama ps. Ukuran model, persentase GPU, dan context hanyalah indikator teknis.

Ukuran sebenarnya adalah apakah agent mampu:

memahami requirement
membuat kode lengkap
menggunakan tools
menjalankan aplikasi
menjalankan test
membaca error
memperbaiki error
menjaga business logic
dan akhirnya menghasilkan aplikasi yang benar-benar berjalan.

Dengan kata lain, model yang lebih besar baru bernilai jika tambahan kapasitasnya mengurangi jumlah pekerjaan yang harus diperbaiki manusia.

AI, General

AI, komputer, programming, technology

Aditya Pratama