Small Language Model (SLM) sedang naik daun di dunia teknologi. Berbeda dengan large language model raksasa seperti GPT-4o atau Claude yang berjalan di server cloud milik perusahaan besar, SLM adalah model bahasa dengan jumlah parameter yang jauh lebih kecil — cukup ringan untuk berjalan di laptop, bahkan di perangkat edge seperti Raspberry Pi. Artikel ini akan memandumu menjalankan SLM secara lokal menggunakan Ollama dan Python: gratis, privat, dan bisa berjalan sepenuhnya tanpa koneksi internet.

Apa Itu Small Language Model (SLM)?

Secara sederhana, SLM adalah model bahasa dengan jumlah parameter relatif kecil — biasanya di bawah 10 miliar parameter, dibandingkan LLM besar yang bisa mencapai ratusan miliar hingga triliunan parameter. Contoh populer adalah Llama 3.2 (3B), Qwen2.5 (7B), Gemma 3 (4B), dan Phi-4 (14B). Karena ukurannya kecil, SLM membutuhkan memori dan daya komputasi yang jauh lebih rendah, sehingga bisa dijalankan langsung di perangkatmu sendiri.

Tren ini bukan tanpa alasan: topik small models belakangan ramai diperbincangkan komunitas developer, menandai makin matangnya model-model kecil yang kini mampu menangani tugas seperti chat, peringkasan teks, hingga coding sederhana dengan kualitas yang mengejutkan. Buat kamu yang ingin memanfaatkan AI tanpa mengirim data ke pihak ketiga, SLM adalah jawabannya.

Kenapa Menjalankan AI Secara Lokal?

Ada beberapa alasan kuat memilih menjalankan SLM secara lokal dibandingkan memakai API cloud:

  • Privasi — data kamu tidak pernah meninggalkan perangkat, cocok untuk dokumen sensitif.
  • Gratis — tidak ada biaya per token seperti API komersial.
  • Offline — tetap berfungsi tanpa koneksi internet.
  • Kontrol penuh — kamu bebas memilih model dan mengatur parameter.
  • Latensi rendah — tanpa antrean jaringan, respons bisa terasa lebih cepat untuk beberapa kasus.
Prasyarat

Sebelum mulai, pastikan kamu punya:

  • Komputer dengan RAM minimal 8 GB (untuk model 1B–3B) atau 16 GB untuk model 7B ke atas.
  • Sekitar 2–5 GB ruang disk kosong per model.
  • Python 3.8 atau lebih baru (untuk bagian Python).
  • Koneksi internet hanya untuk mengunduh model pertama kali.

Punya laptop dengan RAM terbatas (4–8 GB)? Mulailah dari model paling ringan seperti qwen2.5:0.5b atau llama3.2:1b — keduanya berukuran di bawah 1,5 GB dan tetap cukup berguna untuk tugas sederhana.

Langkah 1: Install Ollama

Ollama adalah alat yang memudahkan kita mengunduh, mengelola, dan menjalankan model bahasa lokal. Ia menyediakan antarmuka baris perintah (CLI) sekaligus server lokal yang bisa dipanggil dari Python. Cara tercepat memasangnya adalah lewat skrip instalasi resmi.

bash
# Linux & WSL — jalankan skrip instalasi resmi Ollama
curl -fsSL https://ollama.com/install.sh | sh

# macOS — bisa memakai Homebrew
brew install ollama

# Verifikasi versi
ollama --version

Pengguna Windows bisa mengunduh installer dari situs resmi ollama.com/download dan menjalankannya seperti aplikasi biasa. Setelah terpasang, pastikan service Ollama berjalan — di Linux dan macOS service ini biasanya otomatis aktif setelah instalasi.

Langkah 2: Menarik (Pull) dan Menjalankan Model SLM

Setelah Ollama terpasang, kita unduh model SLM pilihan. Model diunduh satu kali, lalu bisa dipakai berulang kali secara offline.

bash
# Unduh model Llama 3.2 (sekitar 2 GB)
ollama pull llama3.2

# Lihat daftar model yang sudah terunduh
ollama list

# Coba jalankan langsung dari terminal
ollama run llama3.2

Perintah ollama run membuka sesi chat interaktif di terminal. Ketik pertanyaanmu lalu tekan Enter; untuk keluar, ketik /bye. Model lain bisa diunduh dengan cara yang sama, misalnya ollama pull qwen2.5:7b.

Langkah 3: Install Library Python ollama

Untuk mengendalikan Ollama lewat Python, kita butuh package resmi ollama. Instal lewat pip:

bash
pip install ollama

Library ini berbicara ke server lokal Ollama yang berjalan di http://localhost:11434. Pastikan service Ollama aktif sebelum menjalankan kode Python di bawah.

Langkah 4: Chat Pertama dengan Python

Berikut kode paling sederhana untuk mengirim pesan ke model dan mencetak jawabannya:

python
import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[
        {"role": "system", "content": "Kamu adalah asisten yang ramah dan membantu."},
        {"role": "user", "content": "Jelaskan apa itu small language model dalam 3 kalimat."},
    ],
)

print(response["message"]["content"])

Fungsi ollama.chat() menerima parameter model dan messages. Pesan system berfungsi mengatur kepribadian asisten, sedangkan user adalah pertanyaanmu. Hasilnya bisa diakses lewat response["message"]["content"].

Tips memilih model: gunakan llama3.2 untuk tugas serba guna, qwen2.5 jika kamu sering mengerjakan coding, dan gemma3 untuk jawaban yang ringkas dan aman. Kamu bisa berpindah model kapan saja hanya dengan mengganti nilai parameter model.

Langkah 5: Streaming Respons Real-time

Pada model besar, jawaban bisa memakan waktu beberapa detik. Agar terasa seperti chatbot sungguhan, kita bisa menampilkan respons secara bertahap (streaming) menggunakan parameter stream=True:

python
import ollama

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Tuliskan pantun tentang programmer."}],
    stream=True,
)

for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)
print()  # baris baru di akhir

Dengan stream=True, fungsi mengembalikan generator yang menghasilkan potongan teks seiring model “mengetik”. Kita mencetak setiap potongan tanpa baris baru (end="") agar hasilnya tampak mengalir.

Langkah 6: Output JSON Terstruktur

SLM juga bisa dipaksa mengeluarkan JSON valid — sangat berguna saat kamu ingin memproses hasilnya dengan program. Cukup tambahkan format="json":

python
import ollama
import json

response = ollama.chat(
    model="llama3.2",
    messages=[
        {
            "role": "user",
            "content": "Sebutkan 3 bahasa pemrograman terpopuler beserta tahun rilisnya. Balas dalam format JSON.",
        }
    ],
    format="json",
)

data = json.loads(response["message"]["content"])
print(json.dumps(data, indent=2))

Dengan format="json", Ollama memberi instruksi khusus pada model agar hanya menghasilkan JSON yang valid, sehingga aman di-parse menggunakan json.loads().

Model lokal butuh RAM. Saat sebuah model dimuat, ia menempati memori sebesar ukuran file-nya (misal llama3.2 3B ≈ 2–3 GB RAM). Tutup aplikasi berat lain atau gunakan model lebih kecil bila laptopmu mulai lambat. Model yang lama tidak dipakai akan otomatis dilepas dari memori oleh Ollama.

Langkah 7: Embedding untuk Pencarian Semantik

Selain chat, SLM bisa menghasilkan embedding — representasi vektor dari teks yang menangkap maknanya. Embedding berguna untuk pencarian semantik, klasifikasi, dan sistem RAG. Ollama menyediakannya lewat fungsi ollama.embed():

python
import ollama

result = ollama.embed(
    model="llama3.2",
    input="Small language model adalah model bahasa dengan jumlah parameter kecil.",
)

vector = result["embeddings"][0]
print(f"Panjang vektor: {len(vector)}")
print(f"Lima nilai pertama: {vector[:5]}")

Hasil embeddings berupa daftar vektor (satu untuk setiap teks input). Semakin mirip makna dua teks, semakin dekat pula jarak kedua vektornya — prinsip inilah yang mendasari pencarian semantik.

Langkah 8: Membangun Chatbot CLI Sederhana

Sebagai penutup, mari rangkai semua konsep di atas menjadi satu chatbot terminal utuh yang menyimpan riwayat percakapan. Simpan sebagai chatbot.py:

python
# chatbot.py — chatbot SLM lokal dengan riwayat percakapan
import ollama

MODEL = "llama3.2"
SYSTEM_PROMPT = (
    "Kamu adalah asisten AI yang ramah dan ringkas. "
    "Selalu jawab dalam Bahasa Indonesia."
)


def main():
    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
    print(f"🤖 Chatbot SLM ({MODEL}) — ketik 'keluar' untuk berhenti.\n")

    while True:
        try:
            user_input = input("Kamu: ").strip()
        except (EOFError, KeyboardInterrupt):
            print("\nSampai jumpa! 👋")
            break

        if user_input.lower() in ("keluar", "exit", "quit"):
            print("Sampai jumpa! 👋")
            break
        if not user_input:
            continue

        messages.append({"role": "user", "content": user_input})

        stream = ollama.chat(model=MODEL, messages=messages, stream=True)

        print("Bot: ", end="", flush=True)
        full_reply = ""
        for chunk in stream:
            piece = chunk["message"]["content"]
            full_reply += piece
            print(piece, end="", flush=True)
        print("\n")

        messages.append({"role": "assistant", "content": full_reply})


if __name__ == "__main__":
    main()

Jalankan dengan perintah berikut:

bash
python chatbot.py

Script ini menyimpan seluruh riwayat percakapan di variabel messages sehingga model “mengingat” konteks pertanyaan sebelumnya. Kamu bisa mengganti MODEL dengan model lain yang sudah kamu unduh.

Model SLM Populer yang Bisa Kamu Coba

Berikut beberapa model SLM yang bisa langsung kamu unduh dan bandingkan sendiri:

bash
# Serba guna
ollama pull llama3.2        # Llama 3.2 3B (Meta)
ollama pull mistral         # Mistral 7B — cepat dan efisien

# Kuat untuk coding & reasoning
ollama pull qwen2.5:7b      # Qwen2.5 7B (Alibaba)
ollama pull phi4            # Phi-4 14B (Microsoft)

# Ringkas & aman
ollama pull gemma3:4b       # Gemma 3 4B (Google)

# Paling ringan (laptop RAM kecil)
ollama pull llama3.2:1b     # sekitar 1,3 GB
ollama pull qwen2.5:0.5b    # sekitar 400 MB

Ukuran file tiap model berbeda-beda, jadi sesuaikan dengan kapasitas disk dan RAM-mu. Tidak ada satu model terbaik untuk semua kasus — cobalah beberapa dan rasakan sendiri perbedaannya.

Kesimpulan

Menjalankan Small Language Model secara lokal kini sangat mudah berkat Ollama dan library Python-nya. Kamu sudah belajar cara menginstal Ollama, mengunduh model, melakukan chat dasar, streaming, menghasilkan JSON terstruktur, membuat embedding, hingga merangkai chatbot CLI utuh — semuanya tanpa mengirim satu pun data ke cloud.

Langkah berikutnya yang bisa kamu eksplorasi: membangun sistem RAG (retrieval-augmented generation) di atas embedding lokal, atau memakai SLM untuk otomatisasi tugas di aplikasimu sendiri. Selamat bereksperimen! 🚀

Mau lanjut lebih dalam? Cek juga tutorial kami tentang RAG dan AI agent untuk membangun aplikasi AI yang lebih canggih di atas fondasi model lokal ini.