Apa itu Ollama? Cara Menginstal Ollama?

💡

Ingin alat Pengujian API yang hebat yang menghasilkan Dokumentasi API yang indah?

Ingin platform terintegrasi, All-in-One untuk Tim Pengembang Anda bekerja sama dengan produktivitas maksimum?

Apidog memenuhi semua permintaan Anda, dan menggantikan Postman dengan harga yang jauh lebih terjangkau!

button

Lanskap kecerdasan buatan (AI) terus berkembang dengan kecepatan tinggi, dan Model Bahasa Besar (LLM) menjadi semakin kuat dan mudah diakses. Meskipun banyak orang berinteraksi dengan model ini melalui layanan berbasis cloud, ada gerakan yang berkembang yang berfokus pada menjalankannya secara langsung di komputer pribadi. Di sinilah Ollama berperan. Ollama adalah alat yang kuat namun ramah pengguna, dirancang untuk menyederhanakan secara drastis proses kompleks mengunduh, mengonfigurasi, dan menjalankan LLM canggih seperti Llama 3, Mistral, Gemma, Phi, dan banyak lainnya, secara lokal.

Panduan komprehensif ini berfungsi sebagai titik awal Anda untuk menguasai Ollama. Kita akan membahas mulai dari langkah-langkah instalasi awal dan interaksi dasar dengan model hingga teknik penyesuaian yang lebih canggih, penggunaan API, dan pemecahan masalah penting. Apakah Anda seorang pengembang yang ingin mengintegrasikan AI lokal ke dalam aplikasi Anda, seorang peneliti yang tertarik bereksperimen dengan berbagai arsitektur model, atau sekadar penggemar AI yang ingin menjelajahi potensi menjalankan model yang kuat secara offline, Ollama menyediakan portal yang sangat dioptimalkan dan efisien.

Mengapa memilih Ollama untuk Menjalankan LLM Lokal?

Sebelum mendalami detail teknis, penting untuk memahami keuntungan menarik menggunakan Ollama untuk operasi LLM lokal. Mengapa memilih pendekatan ini daripada hanya mengandalkan API cloud yang sudah tersedia?

Privasi dan Keamanan Tak Tertandingi dengan Ollama: Saat Anda menjalankan LLM menggunakan Ollama di mesin Anda, setiap bagian data – prompt Anda, dokumen yang Anda berikan, dan teks yang dihasilkan oleh model – sepenuhnya berada di sistem lokal Anda. Itu tidak pernah meninggalkan perangkat keras Anda. Ini memastikan tingkat privasi dan kontrol data tertinggi, faktor penting saat berhadapan dengan informasi pribadi yang sensitif, data bisnis rahasia, atau penelitian hak milik.
Penghematan Biaya yang Signifikan melalui Ollama: API LLM berbasis cloud sering kali beroperasi dengan model bayar sesuai penggunaan atau memerlukan biaya berlangganan berkelanjutan. Biaya ini dapat menumpuk dengan cepat, terutama dengan penggunaan berat. Ollama menghilangkan biaya berulang ini. Selain investasi awal pada perangkat keras yang sesuai (yang mungkin sudah Anda miliki), menjalankan model secara lokal pada dasarnya gratis, memungkinkan eksperimen dan pembuatan tanpa batas tanpa kekhawatiran tagihan API yang membayangi.
Kemampuan Offline Sejati dengan Ollama: Setelah model Ollama diunduh ke penyimpanan lokal Anda, model itu milik Anda untuk digunakan kapan saja, di mana saja, sepenuhnya independen dari koneksi internet. Akses offline ini sangat berharga bagi pengembang yang bekerja di lingkungan dengan konektivitas terbatas, peneliti di lapangan, atau siapa saja yang membutuhkan akses AI yang andal saat bepergian.
Kustomisasi Mendalam dan Eksperimen melalui Modelfiles Ollama: Ollama membedakan dirinya dengan sistem Modelfile yang kuat. Ini memungkinkan pengguna untuk dengan mudah memodifikasi perilaku model dengan menyesuaikan parameter (seperti tingkat kreativitas atau panjang output), mendefinisikan prompt sistem kustom untuk membentuk persona AI, atau bahkan mengintegrasikan adaptor khusus yang disetel (LoRA). Anda juga dapat mengimpor bobot model secara langsung dari format standar như GGUF atau Safetensors. Tingkat kontrol dan fleksibilitas granular ini jarang ditawarkan oleh penyedia API cloud sumber tertutup.
Potensi Keunggulan Kinerja dengan Ollama: Tergantung pada konfigurasi perangkat keras lokal Anda, terutama keberadaan Unit Pemrosesan Grafis (GPU) yang mumpuni, Ollama dapat memberikan waktu respons (kecepatan inferensi) yang jauh lebih cepat dibandingkan dengan layanan cloud, yang mungkin tunduk pada latensi jaringan, pembatasan kecepatan, atau beban variabel pada sumber daya bersama. Memanfaatkan perangkat keras khusus Anda dapat menghasilkan pengalaman yang jauh lebih lancar dan interaktif.
Keterlibatan dengan Ekosistem Sumber Terbuka Ollama yang Semarak: Ollama sendiri adalah proyek sumber terbuka, mendorong transparansi dan kontribusi komunitas. Selain itu, ini terutama berfungsi sebagai pintu gerbang ke perpustakaan LLM yang dapat diakses secara terbuka yang luas dan berkembang pesat. Dengan menggunakan Ollama, Anda menjadi bagian dari ekosistem dinamis ini, mendapat manfaat dari pengetahuan bersama, dukungan komunitas, dan inovasi berkelanjutan yang didorong oleh kolaborasi terbuka.

Pencapaian utama Ollama adalah menyembunyikan kompleksitas inheren yang terlibat dalam menyiapkan lingkungan perangkat lunak yang diperlukan, mengelola dependensi, dan mengonfigurasi pengaturan rumit yang diperlukan untuk menjalankan model AI canggih ini. Ini dengan cerdik memanfaatkan mesin inferensi backend yang sangat dioptimalkan, terutama pustaka llama.cpp yang terkenal, untuk memastikan eksekusi yang efisien pada perangkat keras konsumen standar, mendukung akselerasi CPU dan GPU.

Memahami Ollama vs. Llama.cpp

Penting untuk mengklarifikasi hubungan antara Ollama dan llama.cpp, karena keduanya terkait erat namun melayani tujuan yang berbeda.

llama.cpp: Ini adalah pustaka C/C++ dasar dan berkinerja tinggi yang bertanggung jawab atas tugas inti inferensi LLM. Ini menangani pemuatan bobot model, pemrosesan token input, dan pembuatan token output secara efisien, dengan pengoptimalan untuk berbagai arsitektur perangkat keras (set instruksi CPU seperti AVX, akselerasi GPU melalui CUDA, Metal, ROCm). Ini adalah mesin kuat yang melakukan pekerjaan komputasi berat.
Ollama: Ini adalah aplikasi komprehensif yang dibangun di sekitar llama.cpp (dan berpotensi backend lain di masa mendatang). Ollama menyediakan lapisan ramah pengguna di atasnya, menawarkan:
Antarmuka Baris Perintah (CLI) sederhana untuk interaksi yang mudah (ollama run, ollama pull, dll.).
Server API REST bawaan untuk integrasi terprogram.
Manajemen model yang disederhanakan (mengunduh dari perpustakaan, penyimpanan lokal, pembaruan).
Sistem Modelfile untuk kustomisasi dan pembuatan varian model.
Penginstal lintas platform (macOS, Windows, Linux) dan gambar Docker.
Deteksi dan konfigurasi perangkat keras otomatis (CPU/GPU).

Intinya, meskipun secara teknis Anda dapat menggunakan llama.cpp secara langsung dengan mengompilasinya dan menjalankan alat baris perintahnya, ini membutuhkan upaya teknis yang jauh lebih signifikan terkait penyiapan, konversi model, dan manajemen parameter. Ollama mengemas kekuatan ini ke dalam aplikasi yang mudah diakses dan digunakan, menjadikan LLM lokal praktis untuk audiens yang jauh lebih luas, terutama bagi pemula. Pikirkan llama.cpp sebagai komponen mesin berkinerja tinggi, dan Ollama sebagai kendaraan yang dirakit lengkap dan ramah pengguna, siap dikendarai.

Menginstal Ollama di Sistem Anda

Ollama dirancang untuk aksesibilitas, menawarkan prosedur instalasi yang mudah untuk macOS, Windows, Linux, dan lingkungan Docker.

Persyaratan Sistem Umum untuk Ollama:

RAM (Memori): Ini seringkali menjadi faktor paling kritis.
Minimal 8 GB: Cukup untuk model yang lebih kecil (misalnya, parameter 1B, 3B, 7B), meskipun kinerjanya mungkin lambat.
Direkomendasikan 16 GB: Titik awal yang baik untuk menjalankan model 7B dan 13B dengan nyaman.
Ideal 32 GB atau lebih: Diperlukan untuk model yang lebih besar (30B, 40B, 70B+) dan memungkinkan jendela konteks yang lebih besar. Lebih banyak RAM umumnya menghasilkan kinerja yang lebih baik dan kemampuan untuk menjalankan model yang lebih besar dan lebih mumpuni.
Ruang Disk: Aplikasi Ollama itu sendiri relatif kecil (beberapa ratus MB). Namun, LLM yang Anda unduh membutuhkan ruang yang cukup besar. Ukuran model sangat bervariasi:
Model Terkuantisasi Kecil (misalnya, ~3B Q4): ~2 GB
Model Terkuantisasi Sedang (misalnya, 7B/8B Q4): 4-5 GB
Model Terkuantisasi Besar (misalnya, 70B Q4): ~40 GB
Model Sangat Besar (misalnya, 405B): Lebih dari 200 GB!
Pastikan Anda memiliki cukup ruang kosong di drive tempat Ollama menyimpan model (lihat bagian di bawah).
Sistem Operasi:
macOS: Versi 11 Big Sur atau yang lebih baru. Apple Silicon (M1/M2/M3/M4) direkomendasikan untuk akselerasi GPU.
Windows: Windows 10 versi 22H2 atau yang lebih baru, atau Windows 11. Edisi Home dan Pro keduanya didukung.
Linux: Distribusi modern (misalnya, Ubuntu 20.04+, Fedora 38+, Debian 11+). Persyaratan kernel mungkin berlaku, terutama untuk dukungan GPU AMD.

Menginstal Ollama di macOS

Unduh: Dapatkan file DMG aplikasi Ollama macOS langsung dari situs web resmi Ollama.
Pasang (Mount): Klik dua kali file .dmg yang diunduh untuk membukanya.
Instal: Seret ikon Ollama.app ke folder Aplikasi Anda.
Jalankan: Buka aplikasi Ollama dari folder Aplikasi Anda. Anda mungkin perlu memberikan izin untuk menjalankannya saat pertama kali.
Layanan Latar Belakang: Ollama akan mulai berjalan sebagai layanan latar belakang, ditandai dengan ikon di bilah menu Anda. Mengklik ikon ini akan memberikan opsi untuk keluar dari aplikasi atau melihat log.

Meluncurkan aplikasi secara otomatis memulai proses server Ollama dan menambahkan alat baris perintah ollama ke PATH sistem Anda, membuatnya segera tersedia di aplikasi Terminal (Terminal.app, iTerm2, dll.). Di Mac yang dilengkapi dengan Apple Silicon (chip M1, M2, M3, M4), Ollama secara mulus memanfaatkan GPU bawaan untuk akselerasi melalui API grafis Metal Apple tanpa memerlukan konfigurasi manual apa pun.

Menginstal Ollama di Windows

Unduh: Dapatkan file penginstal OllamaSetup.exe dari situs web Ollama.
Jalankan Penginstal: Klik dua kali file .exe yang diunduh untuk meluncurkan wizard penyiapan. Pastikan Anda memenuhi persyaratan versi Windows minimum (10 22H2+ atau 11).
Ikuti Perintah: Lanjutkan melalui langkah-langkah instalasi, menerima perjanjian lisensi dan memilih lokasi instalasi jika diinginkan (meskipun default biasanya baik-baik saja).

Penginstal mengonfigurasi Ollama untuk berjalan secara otomatis sebagai layanan latar belakang saat sistem Anda dimulai. Ini juga menambahkan executable ollama.exe ke PATH sistem Anda, memungkinkan Anda menggunakan perintah ollama di terminal Windows standar seperti Command Prompt (cmd.exe), PowerShell, atau Terminal Windows yang lebih baru. Server API Ollama dimulai secara otomatis dan mendengarkan di http://localhost:11434.

Akselerasi GPU Ollama untuk Windows:

NVIDIA: Instal driver GeForce Game Ready atau NVIDIA Studio terbaru dari situs web NVIDIA. Diperlukan driver versi 452.39 atau yang lebih baru. Ollama harus secara otomatis mendeteksi dan memanfaatkan GPU yang kompatibel.
AMD: Instal driver AMD Software: Adrenalin Edition terbaru dari situs web dukungan AMD. GPU Radeon yang kompatibel (biasanya seri RX 6000 dan yang lebih baru) akan digunakan secara otomatis.

Menginstal Ollama di Linux

Metode yang paling nyaman untuk sebagian besar distribusi Linux adalah menggunakan skrip instalasi resmi:

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

Perintah ini mengunduh skrip dan menjalankannya menggunakan sh. Skrip melakukan tindakan berikut:

Mendeteksi arsitektur sistem Anda (x86_64, ARM64).
Mengunduh biner Ollama yang sesuai.
Menginstal biner ke /usr/local/bin/ollama.
Memeriksa driver GPU yang diperlukan (NVIDIA CUDA, AMD ROCm) dan menginstal dependensi jika memungkinkan (bagian ini dapat bervariasi tergantung distribusi).
Membuat pengguna dan grup sistem ollama khusus.
Menyiapkan file layanan systemd (/etc/systemd/system/ollama.service) untuk mengelola proses server Ollama.
Mengaktifkan dan memulai layanan ollama, sehingga berjalan secara otomatis saat boot dan di latar belakang.

Instalasi Manual Ollama di Linux & Konfigurasi Systemd:
Jika skrip gagal, atau jika Anda lebih suka kontrol manual (misalnya, menginstal ke lokasi yang berbeda, mengelola pengguna secara berbeda, memastikan versi ROCm tertentu), lihat panduan instalasi Linux terperinci di repositori GitHub Ollama. Langkah-langkah umum meliputi:

Mengunduh biner yang benar untuk arsitektur Anda.
Membuat biner dapat dieksekusi (chmod +x ollama) dan memindahkannya ke lokasi di PATH Anda (misalnya, /usr/local/bin).
(Direkomendasikan) Membuat pengguna/grup sistem: sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama dan sudo groupadd ollama, lalu sudo usermod -a -G ollama ollama. Tambahkan pengguna Anda sendiri ke grup: sudo usermod -a -G ollama $USER.
Membuat file layanan systemd (/etc/systemd/system/ollama.service) dengan pengaturan yang sesuai (pengguna, grup, path eksekusi, variabel lingkungan jika diperlukan). Cuplikan contoh biasanya disediakan dalam dokumentasi.
Memuat ulang daemon systemd: sudo systemctl daemon-reload.
Mengaktifkan layanan untuk memulai saat boot: sudo systemctl enable ollama.
Memulai layanan segera: sudo systemctl start ollama. Anda dapat memeriksa statusnya dengan sudo systemctl status ollama.

Driver GPU Linux Penting untuk Ollama:
Untuk kinerja optimal, sangat disarankan untuk menginstal driver GPU:

NVIDIA: Instal driver NVIDIA proprietary resmi untuk distribusi Anda (misalnya, melalui manajer paket seperti apt atau dnf, atau diunduh dari situs web NVIDIA). Verifikasi instalasi menggunakan perintah nvidia-smi.
AMD (ROCm): Instal toolkit ROCm. AMD menyediakan repositori resmi dan panduan instalasi untuk distribusi yang didukung (seperti Ubuntu, RHEL/CentOS, SLES). Pastikan versi kernel Anda kompatibel. Skrip instalasi Ollama mungkin menangani beberapa dependensi ROCm, tetapi instalasi manual memastikan penyiapan yang benar. Verifikasi dengan rocminfo.

Menggunakan Gambar Docker Resmi Ollama

Docker menawarkan cara agnostik platform untuk menjalankan Ollama dalam container terisolasi, menyederhanakan manajemen dependensi, terutama untuk pengaturan GPU yang kompleks.

Container Ollama Hanya CPU:

docker run -d \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name my_ollama \
  ollama/ollama

-d: Menjalankan container dalam mode detached (latar belakang).
-v ollama_data:/root/.ollama: Membuat volume bernama Docker bernama ollama_data di sistem host Anda dan memetakannya ke direktori /root/.ollama di dalam container. Ini sangat penting untuk mempertahankan model yang Anda unduh. Jika Anda melewatkan ini, model akan hilang saat container dihapus. Anda dapat memilih nama apa saja untuk volume tersebut.
-p 127.0.0.1:11434:11434: Memetakan port 11434 pada antarmuka loopback mesin host Anda (127.0.0.1) ke port 11434 di dalam container. Gunakan 0.0.0.0:11434:11434 jika Anda perlu mengakses container Ollama dari mesin lain di jaringan Anda.
--name my_ollama: Menetapkan nama kustom yang mudah diingat ke container yang sedang berjalan.
ollama/ollama: Menentukan gambar Ollama resmi dari Docker Hub.

Container Ollama dengan GPU NVIDIA:

Pertama, pastikan NVIDIA Container Toolkit terinstal dengan benar di mesin host Anda dan Docker dikonfigurasi untuk menggunakan runtime NVIDIA.
Jalankan container, tambahkan flag --gpus=all:

docker run -d \
  --gpus=all \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name my_ollama_gpu \
  ollama/ollama

Flag ini memberikan akses container ke semua GPU NVIDIA yang kompatibel yang terdeteksi oleh toolkit. Anda dapat menentukan GPU tertentu jika diperlukan (misalnya, --gpus '"device=0,1"').

Container Ollama dengan GPU AMD (ROCm):

Gunakan tag gambar khusus ROCm: ollama/ollama:rocm.
Petakan node perangkat ROCm yang diperlukan dari host ke container:

docker run -d \
  --device /dev/kfd \
  --device /dev/dri \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  --name my_ollama_rocm \
  ollama/ollama:rocm

/dev/kfd: Antarmuka driver fusi kernel.
/dev/dri: Perangkat Infrastruktur Rendering Langsung (seringkali mencakup node render seperti /dev/dri/renderD128).
Pastikan pengguna yang menjalankan perintah docker di host memiliki izin yang sesuai untuk mengakses file perangkat ini (keanggotaan dalam grup seperti render dan video mungkin diperlukan).

Setelah container Ollama berjalan, Anda dapat berinteraksi dengannya menggunakan perintah docker exec untuk menjalankan perintah CLI ollama di dalam container:

docker exec -it my_ollama ollama list
docker exec -it my_ollama ollama pull llama3.2
docker exec -it my_ollama ollama run llama3.2

Atau, jika Anda memetakan port (-p), Anda dapat berinteraksi dengan API Ollama secara langsung dari mesin host Anda atau aplikasi lain yang menunjuk ke http://localhost:11434 (atau IP/port yang Anda petakan).

Di mana Ollama menyimpan model? Memahami Lokasi Penyimpanan Ollama

Mengetahui di mana Ollama menyimpan model yang diunduh sangat penting untuk mengelola ruang disk dan cadangan. Lokasi default bervariasi berdasarkan sistem operasi dan metode instalasi:

Ollama di macOS: Model berada di dalam direktori home pengguna Anda di ~/.ollama/models. ~ mewakili /Users/<NamaPenggunaAnda>.
Ollama di Windows: Model disimpan di direktori profil pengguna Anda di C:\Users\<NamaPenggunaAnda>\.ollama\models.
Ollama di Linux (Instalasi Pengguna / Manual): Mirip dengan macOS, model biasanya disimpan di ~/.ollama/models.
Ollama di Linux (Instalasi Layanan Systemd): Ketika diinstal melalui skrip atau dikonfigurasi sebagai layanan seluruh sistem yang berjalan sebagai pengguna ollama, model sering disimpan di /usr/share/ollama/.ollama/models. Periksa konfigurasi layanan atau dokumentasi jika Anda menggunakan pengaturan non-standar.
Ollama melalui Docker: Di dalam container, path-nya adalah /root/.ollama/models. Namun, jika Anda menggunakan flag -v dengan benar untuk memasang volume Docker (misalnya, -v ollama_data:/root/.ollama), file model sebenarnya disimpan di dalam area volume yang dikelola Docker di mesin host Anda. Lokasi pasti volume Docker tergantung pada pengaturan Docker Anda, tetapi dirancang untuk bertahan secara independen dari container.

Anda dapat mengarahkan lokasi penyimpanan model menggunakan variabel lingkungan OLLAMA_MODELS, yang akan kita bahas di bagian Konfigurasi. Ini berguna jika drive utama Anda kehabisan ruang dan Anda lebih suka menyimpan model besar di SSD khusus atau drive yang lebih besar.

Langkah Pertama Anda dengan Ollama: Menjalankan LLM

Sekarang setelah Ollama terinstal dan server aktif (berjalan melalui aplikasi desktop, layanan systemd, atau container Docker), Anda dapat mulai berinteraksi dengan LLM menggunakan perintah ollama sederhana di terminal Anda.

Mengunduh Model Ollama: Perintah `pull`

Sebelum Anda dapat menjalankan LLM tertentu, Anda harus mengunduh bobot dan file konfigurasinya terlebih dahulu. Ollama menyediakan perpustakaan pilihan model terbuka populer, mudah diakses melalui perintah ollama pull. Anda dapat menelusuri model yang tersedia di halaman perpustakaan situs web Ollama.

# Contoh 1: Tarik model Llama 3.2 8B Instruct terbaru
# Ini sering ditandai sebagai 'latest' atau hanya dengan nama dasar.
ollama pull llama3.2

# Contoh 2: Tarik versi spesifik Mistral (7 Miliar parameter, model dasar)
ollama pull mistral:7b

# Contoh 3: Tarik model Gemma 3 4B Google
ollama pull gemma3

# Contoh 4: Tarik model Phi-4 Mini Microsoft yang lebih kecil (efisien)
ollama pull phi4-mini

# Contoh 5: Tarik model visi (dapat memproses gambar)
ollama pull llava

Memahami Tag Model Ollama:
Model di perpustakaan Ollama menggunakan konvensi penamaan nama_keluarga_model:tag. Tag menentukan variasi seperti:

Ukuran: 1b, 3b, 7b, 8b, 13b, 34b, 70b, 405b (menunjukkan miliaran parameter). Model yang lebih besar umumnya memiliki lebih banyak pengetahuan tetapi membutuhkan lebih banyak sumber daya.
Kuantisasi: q2_K, q3_K_S, q4_0, q4_K_M, q5_1, q5_K_M, q6_K, q8_0, f16 (float16), f32 (float32). Kuantisasi mengurangi ukuran model dan kebutuhan komputasi, seringkali dengan sedikit penurunan presisi. Angka yang lebih kecil (misalnya, q4) berarti lebih banyak kompresi. Varian K (_K_S, _K_M, _K_L) umumnya dianggap sebagai keseimbangan yang baik antara ukuran dan kualitas. f16/f32 tidak terkuantisasi atau dikompresi secara minimal, menawarkan fidelitas tertinggi tetapi membutuhkan sumber daya paling banyak.
Varian: instruct (disetel untuk mengikuti instruksi), chat (disetel untuk percakapan), code (dioptimalkan untuk tugas pemrograman), vision (multimodal, menangani gambar), uncensored (lebih sedikit filter keamanan, gunakan secara bertanggung jawab).
latest: Jika Anda menghilangkan tag (misalnya, ollama pull llama3.2), Ollama biasanya default ke tag latest, yang biasanya menunjuk ke versi yang umum digunakan dan seimbang (seringkali model berukuran sedang, terkuantisasi, disetel untuk instruksi).

Perintah pull mengunduh file yang diperlukan (yang bisa berukuran beberapa gigabyte) ke direktori model Ollama yang Anda tentukan. Anda hanya perlu menarik kombinasi model:tag tertentu sekali. Ollama juga dapat memperbarui model; menjalankan pull lagi pada model yang ada hanya akan mengunduh lapisan yang diubah (diffs), membuat pembaruan menjadi efisien.

Obrolan Interaktif dengan Model Ollama: Perintah `run`

Cara paling langsung untuk berkomunikasi dengan model yang diunduh adalah menggunakan perintah ollama run:

ollama run llama3.2

Jika model yang ditentukan (llama3.2:latest dalam kasus ini) belum ditarik, ollama run akan dengan mudah memicu ollama pull terlebih dahulu. Setelah model siap dan dimuat ke dalam memori (yang mungkin memakan waktu beberapa detik, terutama untuk model yang lebih besar), Anda akan disajikan dengan prompt interaktif:

>>> Kirim pesan (/? untuk bantuan)

Sekarang, Anda cukup mengetik pertanyaan atau instruksi Anda, tekan Enter, dan tunggu AI menghasilkan respons. Output biasanya mengalir token demi token, memberikan nuansa responsif.

>>> Jelaskan konsep keterikatan kuantum dalam istilah sederhana.
Oke, bayangkan Anda memiliki dua koin khusus yang terhubung bersama secara ajaib. Mari kita sebut Koin A dan Koin B. Sebelum Anda melihatnya, tidak ada koin yang menunjukkan gambar atau angka – mereka berada dalam campuran kabur dari kedua kemungkinan tersebut.

Sekarang, Anda memberikan Koin A kepada seorang teman dan melakukan perjalanan bertahun-tahun cahaya dengan Koin B. Saat Anda melihat Koin B Anda dan melihatnya, katakanlah, gambar, Anda langsung tahu *pasti* bahwa Koin A teman Anda adalah angka. Dan jika Anda melihat angka, Anda akan tahu milik mereka adalah gambar.

Itu seperti keterikatan kuantum! Dua partikel (seperti koin kita) menjadi terhubung, dan sifat-sifatnya (seperti gambar/angka) tetap berkorelasi tidak peduli seberapa jauh jaraknya. Mengukur satu partikel secara instan memengaruhi sifat partikel lainnya, lebih cepat daripada kecepatan cahaya dapat melakukan perjalanan di antara keduanya. Ini adalah salah satu bagian paling aneh dan paling keren dari fisika kuantum!

>>> Kirim pesan (/? untuk bantuan)

Perintah Berguna dalam Mode Interaktif Ollama:
Saat berinteraksi dengan model melalui ollama run, Anda dapat menggunakan perintah khusus yang diawali dengan /:

/?: Menampilkan menu bantuan yang mencantumkan semua perintah garis miring yang tersedia.
/set parameter <nama_parameter> <nilai>: Mengubah sementara parameter runtime model untuk sesi obrolan saat ini. Misalnya, /set parameter temperature 0.9 meningkatkan kreativitas, sementara /set parameter num_ctx 8192 meningkatkan jendela konteks untuk sesi ini.
/show info: Mencetak informasi terperinci tentang model yang sedang dimuat, termasuk parameter, struktur template, dan lisensinya.
/show modelfile: Menampilkan konten Modelfile yang digunakan untuk membuat model yang sedang berjalan. Ini berguna untuk memahami model dasarnya, parameter, dan template promptnya.
/save <nama_sesi>: Menyimpan riwayat obrolan saat ini ke file sesi bernama.
/load <nama_sesi>: Memuat sesi obrolan yang disimpan sebelumnya, memulihkan riwayat percakapan.
/bye atau /exit: Keluar dari sesi obrolan interaktif secara anggun dan membongkar model dari memori (jika tidak ada sesi lain yang menggunakannya). Anda biasanya juga dapat keluar menggunakan Ctrl+D.

Mengelola Model Ollama Lokal Anda

Saat Anda mengunduh dan membuat model, Anda memerlukan cara untuk mengelolanya:

Mencantumkan Model Ollama yang Diunduh: Untuk melihat semua model yang saat ini disimpan secara lokal, gunakan:

ollama list

Perintah ini menampilkan tabel yang menunjukkan nama model (NAME), ID unik, ukuran pada disk (SIZE), dan waktu modifikasi (MODIFIED).

Menampilkan Informasi Model Ollama Terperinci: Untuk memeriksa spesifikasi model tertentu (parameternya, prompt sistem, template, lisensi, dll.), gunakan:

ollama show llama3.2:8b-instruct-q5_K_M

Ini akan mencetak konten Modelfile, pengaturan parameter, detail template, dan metadata lain yang terkait dengan tag model spesifik tersebut.

Menghapus Model Ollama: Jika Anda tidak lagi membutuhkan model dan ingin mengosongkan ruang disk, gunakan:

ollama rm mistral:7b

Ini secara permanen menghapus kombinasi model:tag yang ditentukan dari penyimpanan Anda. Gunakan dengan hati-hati!

Menyalin/Mengganti Nama Model Ollama: Untuk membuat duplikat model yang ada, mungkin sebagai titik awal untuk kustomisasi atau hanya untuk memberinya nama yang berbeda, gunakan:

ollama cp llama3.2 penyiapan-llama3.2-kustom-saya

Ini membuat entri model baru bernama penyiapan-llama3.2-kustom-saya berdasarkan llama3.2 asli.

Memeriksa Model Ollama yang Sedang Dimuat: Untuk melihat model mana yang saat ini dimuat secara aktif ke RAM atau VRAM Anda dan siap untuk inferensi segera, gunakan:

ollama ps

Perintah ini menunjukkan nama model, ID, ukuran, prosesor yang digunakan (CPU/GPU), dan berapa lama yang lalu terakhir diakses. Model biasanya tetap dimuat untuk periode singkat setelah digunakan (misalnya, 5 menit) untuk mempercepat permintaan berikutnya, kemudian dibongkar secara otomatis untuk mengosongkan sumber daya.

Apa model Ollama terbaik? Memilih LLM yang Tepat

Ini adalah pertanyaan yang sering diajukan dan penting, tetapi jawabannya bernuansa. Tidak ada satu model Ollama "terbaik" tunggal untuk semua orang atau setiap tugas. Pilihan optimal bergantung pada beberapa faktor:

Tugas Spesifik Anda: Apa yang utamanya ingin Anda lakukan dengan AI?
Obrolan/Bantuan Umum: llama3.2, llama3.1, mistral, gemma3, qwq adalah pesaing kuat.
Pengkodean/Pemrograman: codellama, phi4, phi4-mini, starcoder2, deepseek-coder secara khusus disetel untuk pembuatan, penjelasan, dan debugging kode.
Penulisan Kreatif: Model dengan suhu default yang lebih tinggi atau jumlah parameter yang lebih besar (seperti model 70B) mungkin menghasilkan hasil yang lebih imajinatif. Eksperimen adalah kuncinya.
Peringkasan/Analisis: Model yang disetel untuk instruksi (tag :instruct) sering kali unggul di sini.
Multimodal (Input Gambar): llava, moondream, llama3.2-vision.
Sumber Daya Perangkat Keras Anda (RAM dan VRAM): Ini adalah batasan utama.
Sumber Daya Rendah (RAM 8GB, Tanpa/GPU Lemah): Tetap gunakan model yang lebih kecil (parameter 1B-3B) atau versi 7B yang sangat terkuantisasi (misalnya, q2_K, q3_K_S). Kinerjanya akan lebih lambat. Contoh: gemma3:1b, llama3.2:1b, phi4-mini:q4_0.
Sumber Daya Kelas Menengah (RAM 16GB, GPU Dasar): Anda dapat dengan nyaman menjalankan model 7B/8B (misalnya, llama3.2, mistral, gemma3) dengan kuantisasi yang baik (q4_K_M, q5_K_M). Anda mungkin dapat menjalankan model 13B (q4_0) secara perlahan.
Sumber Daya Kelas Atas (RAM 32GB+, GPU Kuat dengan VRAM 12GB+): Anda dapat menjalankan model yang lebih besar seperti 13B, 30B, atau bahkan 70B (kuantisasi q4_K_M atau yang lebih baik seperti q5_K_M, q6_K). Ini menawarkan penalaran dan pengetahuan yang jauh lebih baik. Contoh: llama3.3, llama3.1:405b (membutuhkan sumber daya besar), gemma3:27b, deepseek-r1:671b (persyaratan ekstrem).
Trade-off Kualitas vs. Kecepatan yang Diinginkan:
Kualitas Lebih Tinggi: Jumlah parameter yang lebih besar dan kuantisasi yang kurang agresif (misalnya, q6_K, q8_0, f16) umumnya memberikan hasil yang lebih baik tetapi lebih lambat dan membutuhkan lebih banyak sumber daya.
Kecepatan Lebih Cepat/Penggunaan Sumber Daya Lebih Rendah: Jumlah parameter yang lebih kecil dan kuantisasi yang lebih agresif (misalnya, q4_0, q4_K_M, q3_K_M) lebih cepat dan lebih ringan tetapi mungkin menunjukkan sedikit penurunan koherensi atau akurasi. Kuantisasi K (_K_M, _K_S) sering kali memberikan keseimbangan terbaik.
Penyetelan dan Penyelarasan Model: Beberapa model adalah model dasar, sementara yang lain disetel untuk instruksi (instruct) atau disetel untuk obrolan (chat). Model Instruct/chat umumnya lebih baik dalam mengikuti arahan dan terlibat dalam percakapan. Model yang tidak disensor memiliki lebih sedikit pagar pengaman.

Rekomendasi untuk Pemula (Akhir 2024):

Serba Bisa yang Baik (Perangkat Keras Kelas Menengah): llama3.2:8b-instruct-q5_K_M atau mistral:7b-instruct-v0.2-q5_K_M. Ini menawarkan keseimbangan kemampuan, kecepatan, dan penggunaan sumber daya yang hebat.
Opsi Efisien (Perangkat Keras Kelas Bawah): phi4-mini:q4_K_M atau gemma3:1b. Sangat mumpuni untuk ukurannya.
Fokus Pengkodean: codellama:7b-instruct-q5_K_M.
Kebutuhan Visi: llava:13b (jika sumber daya memungkinkan) atau moondream.

Pendekatan terbaik bersifat empiris: Baca deskripsi model di perpustakaan Ollama, pertimbangkan perangkat keras Anda, unduh beberapa kandidat yang mungkin menggunakan ollama pull, uji mereka dengan prompt tipikal Anda menggunakan ollama run, dan lihat mana yang berkinerja terbaik untuk Anda. Jangan ragu untuk ollama rm model yang tidak memenuhi kebutuhan Anda untuk menghemat ruang.

Mendemistifikasi Konsep Model Ollama

Untuk menggunakan dan menyesuaikan Ollama secara efektif, memahami beberapa konsep inti LLM akan membantu.

Parameter Model Ollama Dijelaskan

LLM memiliki pengaturan internal, atau parameter, yang dapat Anda sesuaikan untuk memengaruhi cara mereka menghasilkan teks. Ollama memungkinkan Anda mengontrol banyak di antaranya:

temperature: (Default: ~0.7-0.8) Mengontrol keacakan atau "kreativitas" output.
Nilai yang lebih rendah (misalnya, 0.2): Membuat output lebih deterministik, terfokus, dan dapat diprediksi. Baik untuk jawaban faktual atau pembuatan kode.
Nilai yang lebih tinggi (misalnya, 1.0, 1.2): Meningkatkan keacakan, membuat output lebih beragam dan kreatif, tetapi berpotensi kurang koheren. Baik untuk brainstorming atau penulisan cerita.
top_p (Sampling Inti): (Default: ~0.9) Menetapkan ambang batas probabilitas. Model hanya mempertimbangkan token berikutnya yang paling mungkin yang massa probabilitas kumulatifnya melebihi top_p. Menurunkan top_p (misalnya, 0.5) membatasi pilihan pada kata-kata yang lebih mungkin, meningkatkan koherensi tetapi berpotensi mengurangi kebaruan. Nilai yang lebih tinggi memungkinkan pilihan yang lebih beragam.
top_k: (Default: ~40) Membatasi pilihan model pada k token berikutnya yang paling mungkin. top_k yang lebih rendah (misalnya, 10) membuat output lebih terfokus; top_k yang lebih tinggi memungkinkan lebih banyak variasi. top_p sering dianggap lebih efektif daripada top_k. Biasanya, Anda menetapkan salah satunya, bukan keduanya rendah.
num_predict: (Default: ~128, -1 untuk tak terbatas) Jumlah maksimum token (kira-kira kata/sub-kata) yang akan dihasilkan model dalam satu respons. Tetapkan ke -1 untuk generasi tak terbatas hingga kondisi berhenti terpenuhi.
stop: Daftar urutan teks tertentu. Jika model menghasilkan salah satu urutan ini, model akan segera berhenti menghasilkan output lebih lanjut. Berguna untuk mencegah kalimat berlarut-larut atau memastikan model berhenti setelah menjawab. Contoh: ["\n", "User:", "<|eot_id|>"].
num_ctx: Menentukan ukuran jendela konteks model. Lihat penjelasan terperinci di bawah ini.
Parameter lain: Ollama mengekspos banyak parameter lain yang diwarisi dari llama.cpp (seperti repeat_penalty, seed, mirostat, lapisan GPU num_gpu, dll.) untuk kontrol terperinci. Lihat dokumentasi Ollama dan llama.cpp untuk detailnya.

Anda dapat mengaturnya sementara menggunakan /set parameter di ollama run, secara permanen di Modelfile menggunakan instruksi PARAMETER, atau per permintaan melalui objek options di API Ollama.

Panjang Konteks Ollama: Parameter `num_ctx`

Panjang konteks, sering disebut sebagai jendela konteks atau num_ctx dalam pengaturan Ollama dan llama.cpp, adalah salah satu batasan arsitektur paling kritis dari LLM.

Apa yang diwakilinya: num_ctx menentukan jumlah maksimum token yang dapat "dilihat" atau diproses model secara bersamaan. Ini mencakup semuanya: prompt sistem awal, semua pesan pengguna sebelumnya dan respons asisten dalam riwayat obrolan saat ini, dan prompt input terbaru pengguna.
Mengapa ini penting: Kemampuan model untuk menghasilkan respons yang relevan, koheren, dan sesuai konteks sangat bergantung pada jendela konteksnya.
Percakapan Panjang: Jendela konteks yang lebih besar memungkinkan model untuk "mengingat" informasi dari bagian awal percakapan, mencegahnya kehilangan jejak atau mengulanginya sendiri.
Analisis Dokumen: Saat memproses dokumen besar (misalnya, untuk peringkasan atau menjawab pertanyaan), jendela konteks menentukan seberapa banyak dokumen yang dapat dipertimbangkan model sekaligus.
Instruksi Kompleks: Instruksi yang bergantung pada detail yang diberikan jauh lebih awal dalam prompt memerlukan jendela konteks yang cukup untuk dipahami dengan benar.
Batasan Model Bawaan: Setiap LLM dilatih sebelumnya dengan panjang konteks maksimum tertentu (misalnya, 2048, 4096, 8192, 32k, 128k, atau bahkan jutaan untuk model penelitian mutakhir). Meskipun Anda dapat mengatur num_ctx di Ollama, mengaturnya lebih tinggi dari batas pelatihan asli model mungkin menyebabkan perilaku yang tidak dapat diprediksi, kinerja yang menurun (model mungkin "melupakan" hal-hal di luar jendela yang dilatihnya), atau kesalahan. Mengaturnya lebih rendah selalu aman tetapi membatasi kemampuan model.
Konsumsi Sumber Daya: Memproses jendela konteks yang lebih besar membutuhkan RAM dan VRAM (memori GPU) yang jauh lebih banyak dan membutuhkan waktu komputasi yang lebih lama. Anda perlu menyeimbangkan kemampuan konteks yang diinginkan dengan batasan perangkat keras Anda.
Menemukan num_ctx Default untuk Model Ollama: Gunakan perintah ollama show <nama_model:tag> dan cari baris PARAMETER num_ctx di bagian Modelfile yang ditampilkan. Model Ollama biasanya dikirimkan dengan default yang wajar (misalnya, 4096 atau 8192).
Mengubah num_ctx untuk Ollama:
Sementara (selama ollama run): Gunakan perintah garis miring: /set parameter num_ctx 8192
Per Permintaan API: Sertakan dalam objek JSON options: curl ... -d '{ "model": "...", "prompt": "...", "options": { "num_ctx": 8192 } }'
Permanen (Model Ollama Kustom): Buat atau ubah Modelfile dan tambahkan atau ubah baris PARAMETER num_ctx <nilai>, lalu bangun model menggunakan ollama create. Ini menetapkan ukuran konteks default untuk model kustom tersebut.

Pilih nilai num_ctx yang sesuai dengan tugas tipikal Anda. Untuk Tanya Jawab sederhana, jendela yang lebih kecil (misalnya, 4096) mungkin cukup. Untuk obrolan panjang atau meringkas dokumen besar, Anda akan mendapat manfaat dari jendela konteks terbesar yang dapat didukung secara wajar oleh perangkat keras Anda dan model (misalnya, 8192, 16384, atau lebih jika tersedia).

Ollama Tingkat Lanjut: Memanfaatkan API dan Kustomisasi

Meskipun CLI ollama menawarkan interaksi langsung yang mudah, potensi sebenarnya untuk mengintegrasikan Ollama ke dalam alur kerja dan aplikasi terletak pada API REST bawaannya dan sistem kustomisasi Modelfile.

Berinteraksi secara Terprogram dengan API Ollama

Secara default, proses server Ollama (baik berjalan melalui aplikasi desktop, systemd, atau Docker) mendengarkan permintaan HTTP yang masuk pada port 11434 mesin lokal Anda (http://localhost:11434 atau http://127.0.0.1:11434). API ini memungkinkan program, skrip, atau antarmuka web lain yang berjalan di mesin yang sama (atau mesin lain di jaringan, jika dikonfigurasi) untuk berinteraksi dengan model Ollama secara terprogram.

Titik Akhir API Ollama Utama:

POST /api/generate: Digunakan untuk menghasilkan penyelesaian teks berdasarkan satu prompt non-percakapan. Cocok untuk tugas-tugas seperti perluasan teks, terjemahan sederhana, atau cuplikan kode cepat. Memerlukan body JSON dengan model dan prompt.
POST /api/chat: Dirancang untuk interaksi percakapan. Menerima daftar pesan, masing-masing dengan role (system, user, atau assistant) dan content. Ini memungkinkan model mempertahankan konteks di beberapa giliran. Memerlukan body JSON dengan model dan messages.
POST /api/embeddings: Menghasilkan representasi vektor numerik (embeddings) untuk teks input. Vektor-vektor ini menangkap makna semantik dan fundamental untuk tugas-tugas seperti Generasi yang Ditambah Pengambilan (RAG), pencarian semantik, klasifikasi teks, dan pengelompokan. Memerlukan body JSON dengan model dan prompt.
GET /api/tags: Mengambil daftar semua model yang saat ini tersedia di penyimpanan Ollama lokal Anda (setara dengan ollama list). Mengembalikan array JSON objek model.
POST /api/show: Mengambil informasi terperinci tentang model lokal tertentu, termasuk parameter, template, lisensi, dll. (setara dengan ollama show). Memerlukan body JSON dengan name (model:tag).
DELETE /api/delete: Menghapus model tertentu dari penyimpanan lokal (setara dengan ollama rm). Memerlukan body JSON dengan name (model:tag).
POST /api/pull: Memulai pengunduhan model dari perpustakaan Ollama (setara dengan ollama pull). Memerlukan body JSON dengan name (model:tag). Juga dapat mengalirkan informasi kemajuan.
POST /api/create: Membuat model kustom baru berdasarkan konten Modelfile yang disediakan (setara dengan ollama create -f). Memerlukan body JSON dengan name (nama model baru) dan modelfile (konten Modelfile sebagai string).
POST /api/copy: Menduplikasi model lokal yang ada dengan nama baru (setara dengan ollama cp). Memerlukan body JSON dengan source dan destination.
POST /api/push: Mengunggah model lokal kustom ke akun Anda di registri ollama.com (memerlukan login/pengaturan sebelumnya). Memerlukan body JSON dengan name (nama model dengan namespace).

Format Permintaan/Respons API:
Sebagian besar permintaan POST dan DELETE mengharapkan payload JSON di body permintaan. Respons biasanya dikembalikan sebagai objek JSON. Untuk titik akhir generate dan chat, Anda dapat mengontrol format respons:

"stream": false (Default): API menunggu hingga seluruh respons dihasilkan dan mengembalikannya sebagai satu objek JSON yang berisi teks lengkap, detail penyelesaian, dan statistik kinerja.
"stream": true: API mengembalikan aliran objek JSON, satu untuk setiap token yang dihasilkan (atau potongan kecil token). Ini memungkinkan aplikasi menampilkan respons secara progresif, memberikan pengalaman pengguna yang lebih interaktif. Objek JSON terakhir dalam aliran berisi statistik keseluruhan.

Contoh Interaksi API menggunakan curl:

1. Permintaan Generasi Sederhana (Non-Streaming):

curl http://localhost:11434/api/generate -d '{
  "model": "phi4-mini",
  "prompt": "Tulis fungsi Python singkat untuk menghitung faktorial:",
  "stream": false,
  "options": {
    "temperature": 0.3,
    "num_predict": 80
  }
}'

2. Permintaan Obrolan Percakapan (Streaming):

# Catatan: Output streaming akan muncul sebagai beberapa baris JSON
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2:8b-instruct-q5_K_M",
  "messages": [
    { "role": "system", "content": "Anda adalah sejarawan yang berpengetahuan." },
    { "role": "user", "content": "Apa penyebab utama Perang Dunia I?" }
  ],
  "stream": true,
  "options": {
    "num_ctx": 4096
  }
}'

3. Permintaan Generasi Embedding:

curl http://localhost:11434/api/embeddings -d '{
  "model": "mxbai-embed-large",  # Atau model embedding lain yang sesuai
  "prompt": "Ollama memudahkan menjalankan LLM secara lokal."
}'

API serbaguna ini membentuk tulang punggung untuk integrasi komunitas yang tak terhitung jumlahnya, termasuk antarmuka pengguna web, alat pengembangan, layanan backend, skrip otomatisasi, dan banyak lagi, semuanya didukung oleh instance Ollama lokal Anda.

Memanfaatkan API Kompatibilitas OpenAI Ollama

Menyadari adopsi luas standar API OpenAI, Ollama dengan cermat menyertakan lapisan kompatibilitas eksperimental. Hal ini memungkinkan banyak alat, pustaka, dan aplikasi yang dirancang untuk layanan OpenAI berfungsi dengan instance Ollama lokal Anda dengan modifikasi minimal, seringkali sepele.

Cara Kerjanya:
Server Ollama mengekspos titik akhir di bawah path /v1/ (misalnya, http://localhost:11434/v1/) yang mencerminkan struktur dan format permintaan/respons yang diharapkan dari titik akhir API OpenAI utama.

Titik Akhir Kompatibel Utama:

/v1/chat/completions: Mencerminkan titik akhir penyelesaian obrolan OpenAI.
/v1/embeddings: Mencerminkan titik akhir embeddings OpenAI.
/v1/models: Mencerminkan titik akhir daftar model OpenAI (mengembalikan model Ollama lokal Anda).

Menggunakan Pustaka Klien OpenAI dengan Ollama:
Keuntungan utamanya adalah Anda dapat menggunakan pustaka klien OpenAI standar (seperti openai-python, openai-node, dll.) hanya dengan mengubah dua parameter konfigurasi saat menginisialisasi klien:

base_url (atau api_base): Atur ini ke titik akhir Ollama v1 lokal Anda: http://localhost:11434/v1/.
api_key: Berikan string apa saja yang tidak kosong. Titik akhir /v1/ Ollama sebenarnya tidak melakukan autentikasi dan mengabaikan nilai kunci, tetapi sebagian besar pustaka klien OpenAI mengharuskan parameter tersebut ada. Praktik umum adalah menggunakan string "ollama" atau "nokey".

Contoh Python menggunakan openai-python:

# Pastikan Anda telah menginstal pustaka openai: pip install openai
from openai import OpenAI
import os

# Tentukan titik akhir Ollama dan kunci API tiruan
OLLAMA_BASE_URL = "http://localhost:11434/v1"
OLLAMA_API_KEY = "ollama" # Placeholder, nilai diabaikan oleh Ollama

# Tentukan model Ollama lokal yang ingin Anda gunakan
OLLAMA_MODEL = "llama3.2"

try:
    # Inisialisasi klien OpenAI, arahkan ke server Ollama
    client = OpenAI(
        base_url=OLLAMA_BASE_URL,
        api_key=OLLAMA_API_KEY,
    )

    print(f"Mengirim permintaan ke model Ollama: {OLLAMA_MODEL} melalui lapisan kompatibilitas OpenAI...")

    # Buat permintaan penyelesaian obrolan standar
    chat_completion = client.chat.completions.create(
        model=OLLAMA_MODEL, # Gunakan nama model Ollama lokal Anda
        messages=[
            {"role": "system", "content": "Anda adalah asisten yang membantu."},
            {"role": "user", "content": "Jelaskan perbedaan antara Ollama dan llama.cpp."}
        ],
        temperature=0.7,
        max_tokens=250, # Catatan: 'max_tokens' kira-kira sesuai dengan 'num_predict' Ollama
        stream=False # Atur ke True untuk respons streaming
    )

    # Proses respons
    if chat_completion.choices:
        response_content = chat_completion.choices[0].message.content
        print("\nRespons Ollama:")
        print(response_content)
        print("\nStatistik Penggunaan:")
        print(f"  Token Prompt: {chat_completion.usage.prompt_tokens}")
        print(f"  Token Penyelesaian: {chat_completion.usage.completion_tokens}")
        print(f"  Total Token: {chat_completion.usage.total_tokens}")
    else:
        print("Tidak ada pilihan respons yang diterima dari Ollama.")

except Exception as e:
    print(f"\nTerjadi kesalahan:")
    print(f"  Jenis Kesalahan: {type(e).__name__}")
    print(f"  Detail Kesalahan: {e}")
    print(f"\nPastikan server Ollama berjalan dan dapat diakses di {OLLAMA_BASE_URL}.")
    print(f"Juga verifikasi model '{OLLAMA_MODEL}' tersedia secara lokal ('ollama list').")

Kompatibilitas ini secara signifikan menyederhanakan migrasi proyek berbasis OpenAI yang ada untuk menggunakan model lokal melalui Ollama atau membangun aplikasi baru yang dapat secara fleksibel beralih antara backend cloud dan lokal. Meskipun tidak semua fitur OpenAI yang tidak jelas mungkin dicerminkan dengan sempurna, fungsi inti obrolan, embedding, dan daftar model didukung dengan baik.

Kustomisasi Mendalam Ollama dengan Modelfiles

Modelfile adalah landasan kemampuan kustomisasi Ollama. Ini bertindak sebagai cetak biru atau resep, mendefinisikan secara tepat bagaimana model Ollama harus dibangun atau dimodifikasi. Dengan membuat dan mengedit file teks sederhana ini, Anda mendapatkan kontrol terperinci atas perilaku, parameter, dan struktur model.

Instruksi Modelfile Ollama Inti:

FROM <referensi_model_dasar>: (Instruksi Pertama Wajib) Menentukan fondasi tempat model baru Anda dibangun. Referensi dapat menunjuk ke:
Model yang ada di perpustakaan Ollama lokal Anda atau registri resmi (misalnya, FROM llama3.2:8b-instruct-q5_K_M).
Jalur relatif atau absolut ke direktori lokal yang berisi bobot model yang belum dibongkar dalam format Safetensors, bersama dengan file konfigurasi yang diperlukan (config.json, tokenizer.json, dll.). Contoh: FROM /mnt/models/my_downloaded_llama/. Ollama akan mencoba memuat arsitektur yang didukung (Llama, Mistral, Phi, Gemma, dll.).
Jalur relatif atau absolut ke satu file model dalam format GGUF populer (yang mengemas bobot dan metadata). Contoh: FROM ./models/mistral-7b-instruct-v0.2.Q5_K_M.gguf.
PARAMETER <nama_parameter> <nilai>: Menetapkan nilai parameter runtime default untuk model yang sedang dibuat. Default ini akan digunakan kecuali diganti selama ollama run (melalui /set parameter), melalui opsi panggilan API, atau oleh instruksi PARAMETER berikutnya dalam Modelfile yang sama.
PARAMETER temperature 0.6
PARAMETER num_ctx 8192 (Menetapkan jendela konteks default)
PARAMETER stop "<|user|>"
PARAMETER stop "<|end_of_turn|>" (Anda dapat memiliki beberapa parameter stop)
PARAMETER repeat_penalty 1.15
TEMPLATE "<string_template_prompt>": Menentukan format spesifik yang harus digunakan Ollama untuk menyusun prompt input sebelum memberikannya ke LLM yang mendasarinya. Ini sangat penting untuk model obrolan dan mengikuti instruksi, karena mereka dilatih untuk mengharapkan token atau penanda khusus yang membatasi pesan sistem, giliran pengguna, dan giliran asisten. Template menggunakan sintaks text/template Go. Variabel kunci yang tersedia dalam string template meliputi:
{{ .System }}: Placeholder untuk pesan sistem.
{{ .Prompt }}: Placeholder untuk input pengguna saat ini (digunakan dalam /api/generate).
{{ .Response }}: Placeholder tempat output yang dihasilkan model akan ditambahkan (sering digunakan secara internal atau untuk struktur template tertentu).
{{ range .Messages }} ... {{ .Role }} ... {{ .Content }} ... {{ end }}: Digunakan dalam template obrolan (/api/chat) untuk melakukan iterasi pada seluruh riwayat pesan (giliran sistem, pengguna, asisten) dan memformatnya dengan benar.
{{ .First }}: Nilai boolean yang menunjukkan apakah pesan saat ini adalah pesan pertama (berguna untuk menambahkan token awal urutan khusus).
Contoh (template ChatML yang disederhanakan):

TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>{{ end }}{{ range .Messages }}
<|im_start|>{{ .Role }}
{{ .Content }}<|im_end|>{{ end }}
<|im_start|>assistant
"""

Mendapatkan template yang benar sangat penting untuk membuat model mengikuti instruksi atau berkomunikasi secara alami. Anda dapat melihat template default model menggunakan ollama show --modelfile <nama_model>.

SYSTEM "<pesan_sistem_default>": Menyediakan prompt sistem default yang akan digunakan jika tidak ada pesan sistem lain yang disediakan melalui API atau CLI. Ini berguna untuk menetapkan persona atau set instruksi yang konsisten untuk model.
SYSTEM "Anda adalah asisten AI yang membantu yang berfokus pada memberikan jawaban singkat."
ADAPTER </path/ke/bobot_adapter>: Menerapkan adaptor LoRA (Low-Rank Adaptation) atau QLoRA ke model dasar yang ditentukan dalam instruksi FROM. Adaptor adalah set bobot kecil yang dilatih untuk memodifikasi atau mengkhususkan LLM yang telah dilatih sebelumnya untuk tugas, gaya, atau domain pengetahuan tertentu tanpa melatih ulang seluruh model besar. Path dapat menunjuk ke:
Satu file .gguf yang berisi adaptor.
Direktori yang berisi bobot adaptor dalam format Safetensors (adapter_model.safetensors, adapter_config.json).
Penting: Model dasar (FROM) harus sama dengan model tempat adaptor awalnya dilatih agar berfungsi dengan benar.
LICENSE "<detail_lisensi>": Menyematkan informasi lisensi dalam metadata model. Bisa berupa pengidentifikasi singkat (seperti "MIT") atau blok teks yang lebih panjang.
MESSAGE user "<pesan_pengguna_contoh>" / MESSAGE assistant "<respons_asisten_contoh>": Mendefinisikan giliran percakapan contoh. Ini terkadang dapat membantu memandu nada, gaya, atau format output yang diharapkan model, terutama untuk skenario prompting beberapa contoh (few-shot prompting), meskipun efeknya bervariasi antar model.

Membangun Model Ollama dari Modelfile:
Setelah Anda membuat Modelfile Anda (misalnya, disimpan sebagai MyCustomModel.modelfile), Anda menggunakan perintah ollama create untuk membangun model Ollama yang sesuai:

ollama create nama-model-baru-saya -f MyCustomModel.modelfile

Ollama memproses instruksi, berpotensi menggabungkan lapisan, menerapkan adaptor, menetapkan parameter, dan mendaftarkan model baru (nama-model-baru-saya) di perpustakaan lokal Anda. Anda kemudian dapat menjalankannya seperti model lainnya: ollama run nama-model-baru-saya.

Mengimpor Model Eksternal ke Ollama (GGUF, Safetensors)

Sistem Modelfile Ollama menyediakan cara mulus untuk menggunakan model yang diperoleh dari sumber lain (seperti Hugging Face, peneliti independen, dll.) yang didistribusikan dalam format standar.

Mengimpor Model GGUF ke Ollama: GGUF adalah format populer yang dirancang khusus untuk llama.cpp dan mesin inferensi serupa. Ini mengemas bobot model (seringkali sudah dikuantisasi), informasi tokenizer, dan metadata ke dalam satu file. Ini seringkali merupakan format yang paling mudah untuk diimpor.

Unduh file .gguf (misalnya, zephyr-7b-beta.Q5_K_M.gguf).
Buat Modelfile minimal (misalnya, ZephyrImport.modelfile):

# ZephyrImport.modelfile
FROM ./zephyr-7b-beta.Q5_K_M.gguf

# Penting: Tambahkan template prompt yang benar untuk model ini!
# (Cari format template yang diperlukan model)
TEMPLATE """<|system|>
{{ .System }}</s>
<|user|>
{{ .Prompt }}</s>
<|assistant|>
{{ .Response }}</s>
"""
PARAMETER num_ctx 4096 # Tetapkan konteks default yang wajar
SYSTEM "Anda adalah chatbot yang ramah." # Prompt sistem default opsional

Bangun model Ollama: ollama create my-zephyr-gguf -f ZephyrImport.modelfile.

Mengimpor Model Safetensors (Bobot Penuh) ke Ollama: Safetensors adalah format yang aman dan cepat untuk menyimpan tensor model. Jika Anda memiliki set lengkap bobot dan file konfigurasi untuk model dalam format ini:

Pastikan semua file yang diperlukan (file bobot *.safetensors, config.json, tokenizer.json, special_tokens_map.json, tokenizer_config.json, dll.) terletak di dalam satu direktori (misalnya, /data/models/Mistral-7B-v0.1-full/).
Buat Modelfile yang mereferensikan direktori ini:

# MistralImport.modelfile
FROM /data/models/Mistral-7B-v0.1-full/

# Tambahkan instruksi TEMPLATE, PARAMETER, SYSTEM yang diperlukan
TEMPLATE """[INST] {{ if .System }}{{ .System }} \n{{ end }}{{ .Prompt }} [/INST]
{{ .Response }}"""
PARAMETER num_ctx 4096
PARAMETER temperature 0.7

Bangun model: ollama create my-mistral-safetensors -f MistralImport.modelfile. Ollama akan mencoba memuat arsitektur yang kompatibel. Jika model tidak dikuantisasi (misalnya, FP16), Anda dapat secara opsional mengkuantisasinya selama pembuatan (lihat di bawah).

Menerapkan Adaptor LoRA Safetensors melalui Modelfile Ollama:

Pertama, pastikan Anda memiliki model Ollama dasar yang tepat tempat adaptor LoRA dilatih. Tarik jika perlu (misalnya, ollama pull llama3.2:8b).
Tempatkan file adaptor LoRA (misalnya, adapter_model.safetensors, adapter_config.json) di direktorinya sendiri (misalnya, /data/adapters/my_llama3_lora/).
Buat Modelfile yang menentukan dasar dan adaptor:

# ApplyLora.modelfile
FROM llama3.2:8b # Harus cocok dengan dasar adaptor!

ADAPTER /data/adapters/my_llama3_lora/

# Sesuaikan parameter atau template jika LoRA memerlukannya
PARAMETER temperature 0.5
SYSTEM "Sekarang Anda merespons dengan gaya yang diajarkan oleh LoRA."

Bangun model yang diadaptasi: ollama create llama3-with-my-lora -f ApplyLora.modelfile.

Mengkuantisasi Model dengan Ollama

Kuantisasi adalah proses mengurangi presisi numerik bobot model (misalnya, mengubah angka floating-point 16-bit menjadi bilangan bulat 4-bit). Ini secara signifikan menyusutkan ukuran file model dan jejak memori (penggunaan RAM/VRAM) dan mempercepat inferensi, memungkinkan untuk menjalankan model yang lebih besar dan lebih mampu pada perangkat keras konsumen. Trade-off biasanya berupa penurunan kecil, seringkali tidak kentara, dalam kualitas output.

Ollama dapat melakukan kuantisasi selama proses pembuatan model jika instruksi FROM di Modelfile Anda menunjuk ke bobot model yang tidak dikuantisasi atau presisi lebih tinggi (biasanya Safetensors FP16 atau FP32).

Cara Mengkuantisasi menggunakan ollama create:

Buat Modelfile yang menunjuk ke direktori yang berisi bobot model yang tidak dikuantisasi:

# QuantizeMe.modelfile
FROM /path/to/my/unquantized_fp16_model/
# Tambahkan TEMPLATE, PARAMETER, SYSTEM sesuai kebutuhan

Jalankan perintah ollama create, tambahkan flag -q (atau --quantize) diikuti oleh pengidentifikasi tingkat kuantisasi yang diinginkan:

# Kuantisasi ke Q4_K_M (keseimbangan populer ukuran/kualitas)
ollama create my-quantized-model-q4km -f QuantizeMe.modelfile -q q4_K_M

# Kuantisasi ke Q5_K_M (sedikit lebih besar, kualitas berpotensi lebih baik)
ollama create my-quantized-model-q5km -f QuantizeMe.modelfile -q q5_K_M

# Kuantisasi ke Q8_0 (kuantisasi umum terbesar, kualitas terbaik di antara yang dikuantisasi)
ollama create my-quantized-model-q8 -f QuantizeMe.modelfile -q q8_0

# Kuantisasi ke Q3_K_S (sangat kecil, lebih banyak kehilangan kualitas)
ollama create my-quantized-model-q3ks -f QuantizeMe.modelfile -q q3_K_S

Ollama menggunakan rutinitas kuantisasi dari llama.cpp untuk melakukan konversi dan menyimpan model yang baru dikuantisasi dengan nama yang ditentukan.

Tingkat Kuantisasi Umum:

q4_0, q4_1: Kuantisasi 4-bit dasar.
q5_0, q5_1: Kuantisasi 5-bit dasar.
q8_0: Kuantisasi 8-bit (ukuran file lebih besar, lebih dekat dengan kualitas asli).
q3_K_S, q3_K_M, q3_K_L: Metode "K-Quant" 3-bit yang lebih canggih (variasi internal Kecil/Sedang/Besar). Sangat kecil, trade-off kualitas yang nyata.
q4_K_S, q4_K_M: K-Quant 4-bit canggih. q4_K_M seringkali merupakan titik manis yang direkomendasikan.
q5_K_S, q5_K_M: K-Quant 5-bit canggih. Keseimbangan yang baik, sedikit lebih besar dari Q4_K.
q6_K: K-Quant 6-bit canggih. Ukuran lebih besar, mendekati kualitas Q8.

Memilih tingkat kuantisasi yang tepat tergantung pada batasan perangkat keras Anda dan toleransi terhadap potensi penurunan kualitas. Seringkali layak untuk mencoba q4_K_M atau q5_K_M terlebih dahulu.

Berbagi Model Ollama Kustom Anda

Jika Anda telah membuat varian model unik menggunakan Modelfile – mungkin dengan menerapkan LoRA tertentu, menetapkan prompt sistem dan template kreatif, atau menyempurnakan parameter – Anda dapat membagikan kreasi Anda dengan komunitas Ollama yang lebih luas melalui situs web registri model Ollama resmi.

Langkah-langkah untuk Berbagi Model Ollama:

Buat Akun Ollama: Daftar akun gratis di situs web Ollama (ollama.com). Nama pengguna yang Anda pilih akan menjadi namespace untuk model bersama Anda.
Tautkan Ollama Lokal Anda: Anda perlu mengaitkan instalasi Ollama lokal Anda dengan akun online Anda. Ini melibatkan penambahan kunci publik Ollama mesin lokal Anda ke pengaturan akun Anda di situs web. Situs web menyediakan instruksi spesifik tentang cara menemukan file kunci publik lokal Anda (id_ed25519.pub) berdasarkan sistem operasi Anda.
Beri Nama Model Anda dengan Benar: Model bersama harus diberi namespace dengan nama pengguna Ollama Anda, mengikuti format nama_pengguna_anda/nama_model_anda. Jika model kustom lokal Anda memiliki nama yang berbeda (misalnya, mario), Anda pertama-tama perlu menyalinnya ke nama dengan namespace yang benar menggunakan ollama cp:

# Dengan asumsi nama pengguna Anda adalah 'luigi' dan model lokal adalah 'mario'
ollama cp mario luigi/mario

Dorong Model ke Registri: Setelah model diberi nama dengan benar secara lokal dan kunci Anda ditautkan, gunakan perintah ollama push:

ollama push luigi/mario

Ollama akan mengunggah lapisan model dan metadata yang diperlukan ke registri.

Setelah push selesai, pengguna Ollama lain di seluruh dunia dapat dengan mudah mengunduh dan menjalankan model bersama Anda hanya dengan menggunakan nama namespace-nya:

ollama run luigi/mario

Mekanisme berbagi ini mendorong kolaborasi dan memungkinkan komunitas mendapat manfaat dari model khusus atau yang disesuaikan secara kreatif.

Mengoptimalkan Kinerja Ollama dengan Akselerasi GPU

Meskipun Ollama dapat menjalankan model murni pada CPU komputer Anda, memanfaatkan Unit Pemrosesan Grafis (GPU) yang kompatibel memberikan peningkatan kinerja yang dramatis, secara signifikan mempercepat kecepatan model menghasilkan teks (kecepatan inferensi). Ollama dirancang untuk secara otomatis mendeteksi dan memanfaatkan GPU yang didukung bila memungkinkan.

Ollama dengan GPU NVIDIA: Ollama menawarkan dukungan luar biasa untuk GPU NVIDIA, membutuhkan:

GPU dengan Kemampuan Komputasi CUDA 5.0 atau lebih tinggi (sebagian besar kartu seri GeForce GTX 900 / seri Quadro M dan yang lebih baru). Periksa daftar GPU CUDA NVIDIA untuk kompatibilitas.
Driver NVIDIA proprietary resmi terinstal dengan benar di sistem host Anda (Linux atau Windows).
Di Linux dengan Docker, NVIDIA Container Toolkit harus diinstal dan dikonfigurasi.
Ollama harus secara otomatis mendeteksi perangkat keras dan driver yang kompatibel dan mengalihkan komputasi ke GPU.

Ollama dengan GPU AMD Radeon: Dukungan untuk GPU AMD modern tersedia di Windows dan Linux:

Membutuhkan driver AMD Radeon Software (Adrenalin Edition) terbaru di Windows.
Membutuhkan tumpukan perangkat lunak ROCm (Radeon Open Compute platform) terinstal di Linux (disarankan versi 5 atau 6+). Penginstal Ollama Linux atau gambar Docker :rocm sering membantu dengan dependensi, tetapi instalasi ROCm manual mungkin diperlukan untuk kompatibilitas penuh pada distribusi tertentu.
GPU yang didukung umumnya mencakup seri RX 6000, seri RX 7000, seri PRO W6000/W7000, dan beberapa akselerator Instinct. Periksa dokumentasi GPU Ollama resmi untuk daftar terperinci.

Ollama dengan Apple Silicon (macOS): Pada Mac yang dilengkapi dengan chip seri M1, M2, M3, atau M4, Ollama secara otomatis memanfaatkan kemampuan GPU bawaan melalui API grafis Metal Apple. Biasanya tidak diperlukan instalasi driver atau konfigurasi tambahan; akselerasi GPU berfungsi begitu saja.

Memverifikasi Penggunaan GPU Ollama:
Cara termudah untuk memeriksa apakah Ollama benar-benar menggunakan GPU Anda adalah dengan menjalankan perintah ollama ps saat model dimuat (misalnya, segera setelah memulai ollama run <model> di terminal lain, atau saat permintaan API sedang diproses). Periksa kolom PROCESSOR di output:

gpu: Menunjukkan lapisan model terutama dimuat ke GPU.
cpu: Menunjukkan model berjalan semata-mata pada CPU. Ini bisa berarti tidak ada GPU yang kompatibel terdeteksi, driver hilang atau salah, atau ada masalah saat menginisialisasi dukungan GPU. Periksa log server Ollama untuk kesalahan.

Memilih GPU Spesifik dalam Pengaturan Ollama Multi-GPU:
Jika sistem Anda berisi beberapa GPU yang kompatibel, Anda dapat menginstruksikan Ollama (dan llama.cpp yang mendasarinya) perangkat spesifik mana yang akan digunakan dengan mengatur variabel lingkungan sebelum meluncurkan proses server/aplikasi Ollama:

NVIDIA (CUDA_VISIBLE_DEVICES): Atur variabel ini ke daftar indeks GPU yang dipisahkan koma (dimulai dari 0) atau, lebih disukai, UUID GPU.
export CUDA_VISIBLE_DEVICES=0 (Hanya gunakan GPU pertama yang terdeteksi oleh NVIDIA).
export CUDA_VISIBLE_DEVICES=1 (Hanya gunakan GPU kedua).
export CUDA_VISIBLE_DEVICES=GPU-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,GPU-yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy (Gunakan GPU spesifik yang diidentifikasi oleh UUID mereka, yang dapat Anda temukan menggunakan nvidia-smi -L).
AMD (ROCR_VISIBLE_DEVICES): Atur variabel ini ke daftar indeks GPU yang dipisahkan koma seperti yang dilaporkan oleh perintah rocminfo (biasanya dimulai dari 0).
export ROCR_VISIBLE_DEVICES=0 (Gunakan GPU AMD pertama yang terdeteksi).
export ROCR_VISIBLE_DEVICES=1,2 (Gunakan GPU AMD kedua dan ketiga yang terdeteksi).

Mengatur ID perangkat yang tidak valid (misalnya, export CUDA_VISIBLE_DEVICES=-1) sering digunakan sebagai cara untuk sengaja memaksa Ollama hanya menggunakan CPU, yang dapat berguna untuk debugging. Ingatlah untuk memulai ulang server/aplikasi Ollama setelah mengatur variabel lingkungan ini agar berlaku.

Mengonfigurasi Lingkungan Ollama Anda

Di luar pengaturan default, perilaku Ollama dapat disesuaikan menggunakan berbagai variabel lingkungan. Ini memungkinkan Anda menyesuaikan pengaturan jaringan, lokasi penyimpanan, tingkat logging, dan lainnya.

Variabel Lingkungan Ollama Utama untuk Konfigurasi

OLLAMA_HOST: Mengontrol antarmuka jaringan dan port tempat server API Ollama mendengarkan.
Default: 127.0.0.1:11434 (Hanya mendengarkan pada antarmuka loopback, hanya dapat diakses dari mesin yang sama).
Contoh: 0.0.0.0:11434 (Mendengarkan pada semua antarmuka jaringan yang tersedia, membuat Ollama dapat diakses dari perangkat lain di jaringan lokal Anda. Peringatan: Pastikan aturan firewall yang tepat diterapkan jika mengekspos Ollama secara eksternal).
Contoh: 192.168.1.100:11500 (Hanya mendengarkan pada alamat IP lokal tertentu dan port kustom).
OLLAMA_MODELS: Secara krusial, variabel ini memungkinkan Anda menentukan path direktori kustom tempat Ollama harus menyimpan dan mencari model yang diunduh. Ini sangat berguna jika drive default Anda (tempat ~/.ollama atau C:\Users\<Pengguna>\.ollama berada) kehabisan ruang atau jika Anda lebih suka mengatur model di SSD khusus atau drive yang lebih besar.
Contoh (Linux/macOS): export OLLAMA_MODELS=/mnt/large_drive/my_ollama_models
Contoh (Windows): Atur OLLAMA_MODELS ke D:\OllamaData melalui Properti Sistem.
Penting: Pastikan direktori ada dan akun pengguna yang menjalankan proses server Ollama memiliki izin baca dan tulis penuh untuk path kustom ini.
OLLAMA_ORIGINS: Mengelola Cross-Origin Resource Sharing (CORS) untuk API Ollama. Secara default, browser web membatasi halaman web membuat permintaan API ke domain (asal) yang berbeda dari tempat halaman tersebut disajikan. Jika Anda menjalankan UI web terpisah (seperti Open WebUI, Lobe Chat) yang disajikan dari asal yang berbeda (misalnya, http://localhost:3000) yang perlu memanggil API Ollama Anda (di http://localhost:11434), Anda harus menambahkan asal UI ke variabel ini.
Contoh: export OLLAMA_ORIGINS=http://localhost:3000,http://192.168.1.50:8080 (Mengizinkan permintaan dari dua asal spesifik ini).
Contoh: export OLLAMA_ORIGINS='*' (Mengizinkan permintaan dari asal mana pun. Gunakan dengan hati-hati, terutama jika OLLAMA_HOST bukan 127.0.0.1, karena ini dapat mengekspos API Anda secara luas). Dapat menyertakan protokol seperti chrome-extension://*.
OLLAMA_DEBUG: Atur ke 1 untuk mengaktifkan logging debug verbose. Ini memberikan informasi yang jauh lebih rinci tentang operasi internal Ollama, termasuk langkah-langkah deteksi GPU, detail pemuatan model, dan potensi kesalahan, yang sangat berharga untuk pemecahan masalah.
Contoh: export OLLAMA_DEBUG=1
OLLAMA_KEEP_ALIVE: Mengontrol berapa lama Ollama menyimpan model yang dimuat di memori setelah permintaan terakhirnya. Secara default, mungkin sekitar 5 menit (5m). Mengaturnya ke 0 akan membongkar model segera setelah digunakan (menghemat RAM/VRAM tetapi meningkatkan waktu muat untuk permintaan berikutnya). Mengaturnya ke durasi yang lebih lama (misalnya, 30m) atau -1 (tetap dimuat tanpa batas waktu hingga server berhenti) dapat mempercepat permintaan yang sering ke model yang sama tetapi mengonsumsi sumber daya secara konstan.
Contoh: export OLLAMA_KEEP_ALIVE=15m
HTTPS_PROXY / HTTP_PROXY / NO_PROXY: Variabel lingkungan jaringan standar yang digunakan jika Ollama perlu merutekan permintaan internet keluar (misalnya, saat menjalankan ollama pull untuk mengunduh model dari ollama.com) melalui server proxy, umum di lingkungan perusahaan.
Contoh: export HTTPS_PROXY=http://proxy.mycompany.com:8080

Metode untuk Mengatur Variabel Lingkungan Ollama

Cara yang benar untuk mengatur variabel ini tergantung pada bagaimana Anda menginstal dan menjalankan Ollama:

Ollama di macOS (Menggunakan App): Variabel lingkungan untuk aplikasi GUI di macOS paling baik diatur menggunakan launchctl. Buka Terminal dan gunakan:

launchctl setenv OLLAMA_MODELS "/Volumes/ExternalSSD/OllamaStorage"
launchctl setenv OLLAMA_HOST "0.0.0.0:11434"
# Ulangi untuk variabel lain

Setelah mengatur variabel, Anda harus Keluar dan memulai ulang aplikasi Ollama dari ikon bilah menu agar perubahan berlaku.

Ollama di Linux (Menggunakan Layanan Systemd): Metode yang disarankan adalah membuat file override untuk layanan:

Jalankan sudo systemctl edit ollama.service. Ini membuka editor teks kosong.
Tambahkan baris berikut, ubah variabel dan nilai sesuai kebutuhan:

[Service]
Environment="OLLAMA_MODELS=/path/to/custom/model/dir"
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_DEBUG=1"

Simpan dan tutup editor.
Terapkan perubahan: sudo systemctl daemon-reload
Mulai ulang layanan Ollama: sudo systemctl restart ollama

Ollama di Windows: Gunakan editor Variabel Lingkungan bawaan:

Cari "Edit the system environment variables" di menu Start dan buka.
Klik tombol "Variabel Lingkungan...".
Anda dapat mengatur variabel untuk pengguna spesifik Anda ("Variabel pengguna") atau untuk semua pengguna ("Variabel sistem"). Variabel sistem biasanya memerlukan hak administrator.
Klik "Baru..." di bawah bagian yang diinginkan.
Masukkan Nama variabel (misalnya, OLLAMA_MODELS) dan Nilai variabel (misalnya, D:\OllamaData).
Klik OK pada semua dialog yang terbuka.
Secara krusial, Anda harus memulai ulang proses latar belakang Ollama. Buka Task Manager (Ctrl+Shift+Esc), buka tab "Layanan", temukan "Ollama", klik kanan, dan pilih "Mulai Ulang". Atau, restart komputer Anda.

Ollama melalui Docker: Lewatkan variabel lingkungan secara langsung dalam perintah docker run menggunakan flag -e untuk setiap variabel:

docker run -d \
  --gpus=all \
  -v ollama_data:/root/.ollama \
  -p 127.0.0.1:11434:11434 \
  -e OLLAMA_HOST="0.0.0.0:11434" \
  -e OLLAMA_DEBUG="1" \
  -e OLLAMA_KEEP_ALIVE="10m" \
  --name my_ollama_configured \
  ollama/ollama

Ollama melalui ollama serve manual di Terminal: Cukup awali perintah dengan penetapan variabel pada baris yang sama:

OLLAMA_DEBUG=1 OLLAMA_HOST=0.0.0.0:11434 OLLAMA_MODELS=/data/ollama ollama serve

Variabel ini hanya akan berlaku untuk instance server spesifik tersebut.

Pilih metode yang sesuai untuk penyiapan Anda dan ingatlah untuk memulai ulang proses server Ollama setelah melakukan perubahan agar aktif.

Memecahkan Masalah Umum Ollama

Bahkan dengan fokus Ollama pada kesederhanaan, Anda mungkin sesekali mengalami hambatan. Berikut cara mendiagnosis dan menyelesaikan beberapa masalah umum:

Memeriksa Log Ollama

Alat diagnostik utama Anda adalah file log server Ollama. Ini mencatat informasi startup, upaya pemuatan model, hasil deteksi GPU, permintaan API, dan, yang paling penting, pesan kesalahan terperinci.

Lokasi File Log Default:

Ollama di macOS: ~/.ollama/logs/server.log
Ollama di Linux (Systemd): Gunakan perintah kontrol jurnal: journalctl -u ollama. Tambahkan -f untuk mengikuti log secara real-time (journalctl -u ollama -f). Gunakan -n 100 untuk melihat 100 baris terakhir (journalctl -u ollama -n 100).
Ollama di Windows: File log adalah server.log yang terletak di dalam %LOCALAPPDATA%\Ollama. Anda dapat dengan mudah membuka folder ini dengan menempelkan %LOCALAPPDATA%\Ollama ke bilah alamat File Explorer atau dialog Run (Win+R).
Ollama melalui Docker: Gunakan perintah log Docker: docker logs my_ollama (ganti my_ollama dengan nama container Anda). Tambahkan -f untuk mengikuti (docker logs -f my_ollama).
Ollama melalui ollama serve manual: Log dicetak langsung ke jendela terminal tempat Anda meluncurkan perintah.

Tips: Untuk pemecahan masalah yang lebih rinci, selalu aktifkan logging debug dengan mengatur variabel lingkungan OLLAMA_DEBUG=1 sebelum memulai server Ollama, lalu periksa kembali log.

Memperbaiki Kesalahan Ollama: `listen tcp 127.0.0.1:11434: bind: address already in use`

Pesan kesalahan spesifik ini adalah salah satu masalah paling umum yang dihadapi pengguna baru. Ini berarti Ollama tidak dapat memulai server API-nya karena proses lain sudah menempati port jaringan (default 11434) yang perlu didengarkan Ollama.

Kemungkinan Penyebab:
Instance lain dari server Ollama sudah berjalan di latar belakang (mungkin dari sesi sebelumnya yang tidak dimatikan dengan bersih).
Aplikasi yang sama sekali berbeda di sistem Anda kebetulan menggunakan port 11434.
Solusi 1: Identifikasi dan Hentikan Proses yang Bertentangan: Anda perlu mencari tahu proses mana yang menggunakan port tersebut dan menghentikannya (jika aman untuk melakukannya).
Linux / macOS: Buka terminal dan jalankan sudo lsof -i :11434 atau sudo netstat -tulnp | grep 11434. Perintah ini harus menunjukkan ID Proses (PID) dari program yang menggunakan port tersebut. Anda kemudian dapat mencoba menghentikannya secara anggun atau menggunakan sudo kill <PID>. Jika itu adalah proses Ollama lama, menghentikannya akan menyelesaikan konflik.
Windows: Buka Command Prompt sebagai Administrator dan jalankan netstat -ano | findstr "11434". Lihat kolom terakhir untuk PID. Buka Task Manager (Ctrl+Shift+Esc), buka tab "Details" (atau "Processes" dan tambahkan kolom PID), temukan proses dengan PID tersebut, dan akhiri jika sesuai.
Solusi 2: Ubah Port Mendengarkan Ollama: Jika Anda tidak dapat menghentikan proses yang bertentangan, atau jika Anda sengaja ingin Ollama berjalan di port yang berbeda, Anda dapat mengonfigurasi Ollama untuk menggunakan port alternatif. Atur variabel lingkungan OLLAMA_HOST untuk menyertakan port yang Anda inginkan sebelum memulai Ollama.
Contoh: Atur OLLAMA_HOST ke 127.0.0.1:11435 (menggunakan metode yang dijelaskan di bagian Konfigurasi).
Ingatlah untuk menyesuaikan konfigurasi klien API, UI web, atau skrip apa pun untuk menunjuk ke port baru (misalnya, http://localhost:11435) setelah melakukan perubahan ini.

Menyelesaikan Masalah Deteksi dan Penggunaan GPU Ollama

Jika ollama ps menunjukkan cpu alih-alih gpu, atau jika Anda mengalami kesalahan spesifik terkait GPU di log (seperti CUDA error, ROCm error), ikuti langkah-langkah berikut:

Konfirmasi Kompatibilitas GPU: Periksa kembali apakah model GPU spesifik Anda terdaftar sebagai didukung dalam dokumentasi GPU Ollama resmi di GitHub.
Perbarui Driver: Pastikan Anda telah menginstal driver resmi stabil terbaru dengan benar langsung dari situs web NVIDIA atau AMD. Driver generik yang disertakan dengan OS seringkali tidak cukup. Sangat disarankan untuk melakukan reboot sistem penuh setelah instalasi driver.
Periksa Log Ollama (Mode Debug): Atur OLLAMA_DEBUG=1, mulai ulang server Ollama, dan periksa log startup dengan cermat. Cari pesan yang terkait dengan deteksi GPU, pemuatan pustaka (CUDA, ROCm), dan kode kesalahan spesifik apa pun.
Spesifik NVIDIA (Linux):
Verifikasi perintah nvidia-smi berfungsi dan menunjukkan GPU serta versi driver Anda.
Jika menggunakan Docker, konfirmasikan NVIDIA Container Toolkit terinstal dan berfungsi (docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi).
Periksa apakah modul kernel yang diperlukan dimuat (lsmod | grep nvidia). Terkadang memuat ulang (sudo rmmod nvidia_uvm nvidia && sudo modprobe nvidia_uvm nvidia) dapat membantu.
Periksa log sistem (dmesg | grep -iE 'nvidia|nvrm') untuk kesalahan perangkat keras atau driver.
Spesifik AMD (Linux):
Verifikasi perintah rocminfo berfungsi dan menunjukkan GPU Anda.
Pastikan pengguna yang menjalankan Ollama (atau container Docker) memiliki izin yang benar untuk perangkat /dev/kfd dan /dev/dri/renderD* (seringkali memerlukan keanggotaan dalam grup render dan video). Periksa keanggotaan grup dengan groups $USER atau groups ollama. Anda mungkin memerlukan --group-add render --group-add video dalam perintah Docker Anda.
Periksa log sistem (dmesg | grep -iE 'amdgpu|kfd') untuk kesalahan.
Paksa CPU (untuk pengujian): Sebagai langkah diagnostik sementara, coba paksa penggunaan CPU dengan mengatur CUDA_VISIBLE_DEVICES=-1 atau ROCR_VISIBLE_DEVICES=-1. Jika Ollama berjalan dengan benar di CPU, ini mengonfirmasi masalah terkait dengan penyiapan GPU.

Mengatasi Masalah Umum Ollama Lainnya

Kesalahan Izin (Direktori Model): Terutama di Linux dengan layanan systemd, jika Ollama gagal menarik atau membuat model, ia mungkin tidak memiliki izin tulis untuk direktori penyimpanan model (OLLAMA_MODELS atau default). Pastikan direktori ada dan dimiliki atau dapat ditulis oleh pengguna/grup ollama (sudo chown -R ollama:ollama /path/to/models dan sudo chmod -R 775 /path/to/models).
Pengunduhan Model Lambat (ollama pull):
Periksa kecepatan koneksi internet dasar Anda.
Jika Anda berada di belakang proxy, pastikan HTTPS_PROXY dikonfigurasi dengan benar.
Periksa aturan firewall yang berpotensi memblokir atau membatasi koneksi ke ollama.com.
Di Windows dengan WSL2, masalah LSO (Large Send Offload) yang diketahui terkadang dapat memengaruhi kinerja jaringan dalam WSL. Menonaktifkan LSOv2 untuk adaptor jaringan virtual WSL di pengaturan Adaptor Jaringan Windows mungkin membantu, meskipun ini kurang umum sekarang.
Output Terminal Rusak (ollama run di Windows lama): Jika Anda melihat karakter aneh seperti ←[?25h... di cmd.exe atau PowerShell pada versi Windows 10 yang lebih lama, kemungkinan besar karena dukungan kode escape ANSI yang buruk. Solusi terbaik adalah:
Tingkatkan Windows 10 ke versi 22H2 atau yang lebih baru.
Gunakan Windows 11.
Gunakan aplikasi Windows Terminal modern, yang memiliki dukungan ANSI yang sangat baik.

Jika Anda telah mencoba semua langkah pemecahan masalah ini dan memeriksa log debug tanpa hasil, komunitas Ollama adalah sumber daya yang bagus. Siapkan deskripsi masalah yang jelas, sertakan detail relevan tentang OS Anda, versi Ollama, perangkat keras (CPU/GPU/RAM), model spesifik yang Anda gunakan, perintah yang Anda jalankan, dan secara krusial, bagian relevan dari log debug Anda. Posting pertanyaan Anda di Discord Ollama atau ajukan issue yang terdokumentasi dengan baik di repositori GitHub Ollama.

Cara menghapus instalan Ollama sepenuhnya

Jika Anda perlu menghapus Ollama dari sistem Anda, prosesnya bervariasi berdasarkan metode instalasi awal Anda. Biasanya melibatkan penghapusan aplikasi/biner, layanan latar belakang (jika berlaku), dan file model/konfigurasi yang disimpan.

Menghapus Instalan Ollama di macOS (Diinstal melalui .app):

Keluar dari Ollama: Klik ikon Ollama di bilah menu dan pilih "Keluar dari Ollama".
Hapus Aplikasi: Seret Ollama.app dari folder /Applications Anda ke Tong Sampah/Bin.
Hapus Data dan Konfigurasi: Buka Terminal dan jalankan rm -rf ~/.ollama. Peringatan: Ini menghapus semua model dan konfigurasi yang diunduh secara permanen. Periksa kembali perintah sebelum menjalankan.
(Opsional) Batalkan Pengaturan Variabel Lingkungan: Jika Anda mengatur variabel secara manual menggunakan launchctl setenv, Anda dapat membatalkannya: launchctl unsetenv OLLAMA_HOST, launchctl unsetenv OLLAMA_MODELS, dll.

Menghapus Instalan Ollama di Windows (Diinstal melalui .exe):

Gunakan Penghapus Instalan Windows: Buka "Pengaturan" > "Aplikasi" > "Aplikasi terinstal". Cari "Ollama" dalam daftar, klik tiga titik (...) di sebelahnya, dan pilih "Hapus instalan". Ikuti petunjuk penghapusan instalan.
Hapus Data dan Konfigurasi: Setelah penghapus instalan selesai, hapus direktori data Ollama secara manual. Buka File Explorer, ketik %USERPROFILE%\.ollama di bilah alamat, tekan Enter, dan hapus seluruh folder .ollama. Peringatan: Ini menghapus semua model.
(Opsional) Hapus Variabel Lingkungan: Jika Anda menambahkan OLLAMA_HOST, OLLAMA_MODELS, dll., secara manual melalui Properti Sistem, kembali ke sana ("Edit variabel lingkungan sistem") dan hapus.

Menghapus Instalan Ollama di Linux (Diinstal melalui Skrip atau Biner Manual):

Hentikan Layanan: sudo systemctl stop ollama
Nonaktifkan Layanan: sudo systemctl disable ollama
Hapus Biner: sudo rm /usr/local/bin/ollama (atau path tempat Anda menginstalnya).
Hapus File Layanan: sudo rm /etc/systemd/system/ollama.service
Muat Ulang Systemd: sudo systemctl daemon-reload
(Opsional) Hapus Pengguna/Grup: Jika pengguna/grup ollama dibuat: sudo userdel ollama, sudo groupdel ollama.
Hapus Data dan Konfigurasi: Hapus direktori penyimpanan model. Ini tergantung di mana ia disimpan:

Jika dijalankan sebagai pengguna Anda: rm -rf ~/.ollama
Jika dijalankan sebagai layanan sistem (pengguna ollama): sudo rm -rf /usr/share/ollama/.ollama (atau path yang ditentukan oleh OLLAMA_MODELS dalam file layanan).
Peringatan: Gunakan sudo rm -rf dengan sangat hati-hati. Verifikasi path sudah benar sebelum menjalankan.

Menghapus Instalan Ollama melalui Docker:

Hentikan Container: docker stop my_ollama (gunakan nama container Anda).
Hapus Container: docker rm my_ollama.
Hapus Gambar: docker rmi ollama/ollama (dan ollama/ollama:rocm jika Anda menggunakannya).
(Opsional, Merusak) Hapus Volume: Jika Anda ingin menghapus semua model yang diunduh yang disimpan dalam volume Docker, jalankan docker volume rm ollama_data (gunakan nama volume yang Anda buat). Peringatan: Ini tidak dapat diurungkan.

Kesimpulan: Merangkul Kekuatan AI Lokal dengan Ollama

Ollama berdiri sebagai alat penting dalam mendemokratisasi akses ke kekuatan luar biasa dari Model Bahasa Besar modern. Dengan secara elegan mengabstraksi kompleksitas penyiapan, konfigurasi, dan eksekusi, ia memberdayakan beragam pengguna – mulai dari pengembang dan peneliti berpengalaman hingga penggemar yang ingin tahu – untuk menjalankan AI canggih secara langsung di perangkat keras mereka sendiri. Keuntungannya jelas: privasi yang tak tertandingi, kebebasan dari biaya API berulang, operasi offline yang andal, dan kemampuan membebaskan untuk menyesuaikan dan bereksperimen secara mendalam dengan model menggunakan sistem Modelfile yang intuitif dan API yang kuat.

Apakah tujuan Anda adalah membangun generasi berikutnya dari aplikasi berbasis AI, melakukan penelitian mutakhir sambil mempertahankan kedaulatan data, atau sekadar menjelajahi kemampuan menarik dari generasi bahasa tanpa ketergantungan eksternal, Ollama menyediakan fondasi yang stabil, efisien, dan ramah pengguna. Ia berhasil menjembatani kesenjangan antara kekuatan mentah mesin inferensi seperti llama.cpp dan kebutuhan praktis pengguna, mendorong inovasi dalam lanskap AI sumber terbuka yang semarak.

Perjalanan ke dunia LLM lokal dapat diakses dan sangat bermanfaat, berkat Ollama. Unduh aplikasinya, tarik model pertama Anda menggunakan ollama pull, mulai percakapan dengan ollama run, dan mulailah membuka potensi besar kecerdasan buatan, langsung di mesin Anda sendiri.

💡