README.md

---
license: apache-2.0
base_model: google/gemma-4-12B-it
library_name: gguf
pipeline_tag: text-generation
tags:
- code-generation
- reasoning
- thinking
- gguf
- llama-cpp
- local-llm
- python
- agentic-coding
- offline-ai
language:
- en
- id
inference: false
---

# Blueboop Jigsaw GGUF

## Model Coding Lokal Berbasis Gemma 4 12B

**Blueboop Jigsaw** adalah model AI lokal berbasis `google/gemma-4-12B-it` yang difokuskan untuk kebutuhan **coding**, **reasoning**, **pemecahan masalah algoritmik**, dan **pembuatan kode Python** secara offline melalui format **GGUF**.

Model ini dirancang untuk pengguna yang ingin menjalankan asisten coding pribadi tanpa API cloud, tanpa koneksi server eksternal, dan tetap bisa berjalan di perangkat konsumen menggunakan runtime seperti `llama.cpp`, LM Studio, Jan, Ollama, atau aplikasi lain yang mendukung GGUF.

> Rekomendasi awal: gunakan **Q4_K_M** untuk keseimbangan terbaik antara kualitas, ukuran file, dan performa.

---

## Ringkasan Model

| Informasi           | Detail                                     |
| ------------------- | ------------------------------------------ |
| Nama model          | Blueboop Jigsaw GGUF                       |
| Base model          | `google/gemma-4-12B-it`                    |
| Format              | GGUF                                       |
| Fokus utama         | Coding, reasoning, Python, problem solving |
| Runtime utama       | `llama.cpp`                                |
| Context length      | 256K token                                 |
| Quant rekomendasi   | Q4_K_M                                     |
| Quant paling ringan | Q2_K                                       |
| Lisensi             | Apache 2.0                                 |
| Bisa offline        | Ya                                         |
| Butuh API cloud     | Tidak                                      |

---

## Keunggulan Utama

* Dapat berjalan secara lokal dan offline.
* Cocok untuk coding Python dan latihan algoritma.
* Mendukung reasoning sebelum menghasilkan jawaban.
* Tersedia dalam beberapa pilihan quant GGUF.
* Bisa digunakan di perangkat dengan VRAM atau unified memory terbatas.
* Cocok untuk eksperimen local LLM, coding assistant, dan pembelajaran pemrograman.
* Tidak membutuhkan API berbayar.
* Lebih fokus untuk tugas coding dibanding penggunaan umum.

---

## Arsitektur Alur Kerja

```mermaid
flowchart TD
    A[Prompt Pengguna] --> B[Template Chat Gemma 4]
    B --> C[Tahap Reasoning]
    C --> D[Perencanaan Solusi]
    D --> E[Pembuatan Kode]
    E --> F[Pengecekan Edge Case]
    F --> G[Jawaban Akhir]

    H[File GGUF] --> I[llama.cpp / LM Studio / Jan / Ollama]
    I --> B
```

---

## Data Training

Blueboop Jigsaw menggunakan data coding yang bersifat **verifiable**, yaitu data yang solusi akhirnya dapat diuji menggunakan test case deterministik.

### Dataset Utama: Composer 2.5 Real CoT

Dataset utama berasal dari reasoning trace asli yang dibuat oleh model teacher pada tugas-tugas coding.

Kriteria data yang digunakan:

* Masalah harus berhubungan dengan coding.
* Solusi harus dapat dijalankan.
* Kode harus lolos test case.
* Reasoning harus mengarah ke solusi akhir yang benar.
* Solusi yang gagal atau tidak valid tidak dimasukkan ke training.

### Dataset Tambahan: Fable 5 Recovery Set

Dataset tambahan digunakan untuk memperbaiki kasus yang gagal diselesaikan oleh teacher utama.

Tujuannya:

* Memperbaiki performa pada soal sulit.
* Meningkatkan kemampuan menangani edge case.
* Meningkatkan konsistensi reasoning.
* Membantu model memahami pola debugging dan penyelesaian masalah.

---

## Diagram Training

```mermaid
flowchart LR
    A[Soal Coding] --> B[Percobaan Composer 2.5]
    B --> C{Lolos Test?}
    C -->|Ya| D[Dataset Utama]
    C -->|Tidak| E[Dicoba Ulang oleh Fable 5]
    E --> F{Lolos Test?}
    F -->|Ya| G[Dataset Tambahan]
    F -->|Tidak| H[Dibuang]
    D --> I[Final Training Mix]
    G --> I
    I --> J[Blueboop Jigsaw]
```

---

## Benchmark Ringkas

Benchmark berikut adalah gambaran evaluasi internal. Hasil dapat berubah tergantung hardware, runtime, quantization, prompt template, dan pengaturan sampling.

| Benchmark                    | Gemma 4 12B IT Base | Blueboop Jigsaw v1 | Blueboop Jigsaw v2 Preview |
| ---------------------------- | ------------------: | -----------------: | -------------------------: |
| Python function-level coding |            Baseline |         Lebih baik |                 Lebih kuat |
| Konsistensi reasoning        |            Baseline |         Lebih baik |                 Lebih kuat |
| Edge case handling           |            Baseline |         Lebih baik |                 Lebih kuat |
| tau2-bench telecom Q8_0      |                ~15% |  Belum fokus utama |               ~55% preview |
| Local coding usability       |                Baik |         Lebih baik |              Lebih agentic |

---

## Chart Benchmark

```mermaid
xychart-beta
    title "Preview tau2-bench Telecom"
    x-axis ["Gemma 4 12B IT", "Blueboop Jigsaw v2 Preview"]
    y-axis "Score %" 0 --> 60
    bar [15, 55]
```

---

## Perbandingan Skor Preview

```mermaid
pie title Perbandingan Skor tau2-bench Telecom Preview
    "Gemma 4 12B IT ~15%" : 15
    "Blueboop Jigsaw v2 Preview ~55%" : 55
```

---

## Pilihan Quant GGUF

| Quant  | Ukuran Perkiraan | Rekomendasi Hardware                  | Kualitas      | Cocok Untuk                     |
| ------ | ---------------: | ------------------------------------- | ------------- | ------------------------------- |
| Q2_K   |           4.5 GB | 6 GB sampai 8 GB VRAM/shared memory   | Paling rendah | Perangkat terbatas              |
| Q3_K_M |           5.7 GB | 8 GB VRAM/shared memory               | Cukup baik    | Coding ringan lokal             |
| Q4_K_M |          6.87 GB | 8 GB sampai 12 GB VRAM/shared memory  | Rekomendasi   | Keseimbangan terbaik            |
| Q6_K   |          9.11 GB | 12 GB sampai 16 GB VRAM/shared memory | Tinggi        | Kualitas mendekati penuh        |
| Q8_0   |          11.8 GB | 16 GB+ VRAM/shared memory             | Sangat tinggi | Benchmark dan kualitas maksimal |

---

## Rekomendasi Quant

```mermaid
flowchart TD
    A[Berapa VRAM atau unified memory yang tersedia?] --> B{Kurang dari 8 GB}
    B -->|Ya| C[Gunakan Q2_K]
    B -->|Tidak| D{8 GB sampai 12 GB}
    D -->|Ya| E[Gunakan Q3_K_M atau Q4_K_M]
    D -->|Tidak| F{12 GB sampai 16 GB}
    F -->|Ya| G[Gunakan Q4_K_M atau Q6_K]
    F -->|Tidak| H{16 GB atau lebih}
    H -->|Ya| I[Gunakan Q6_K atau Q8_0]
```

---

## Estimasi Memori dan Context Length

Estimasi berikut menggunakan asumsi:

* KV cache `q8_0`
* Overhead runtime sekitar 1.5 GB
* Context maksimal 256K token
* Hasil nyata bergantung pada runtime, GPU, RAM, sistem operasi, dan backend

| VRAM / Unified Memory |      Q2_K |    Q3_K_M |     Q4_K_M |             Q6_K |             Q8_0 |
| --------------------: | --------: | --------: | ---------: | ---------------: | ---------------: |
|                  8 GB |  ~16K ctx |  ~10K ctx | ~2K–4K ctx | Tidak disarankan | Tidak disarankan |
|                 12 GB |  ~48K ctx |  ~38K ctx |   ~30K ctx |         ~12K ctx | Tidak disarankan |
|                 16 GB |  ~80K ctx |  ~72K ctx |   ~64K ctx |         ~44K ctx |         ~22K ctx |
|                 24 GB | ~200K ctx | ~160K ctx |  ~128K ctx |        ~110K ctx |         ~88K ctx |
|                 32 GB |  256K max |  256K max |   256K max |        ~230K ctx |        ~190K ctx |

---

## Context Length

Metadata model telah diperbarui menjadi:

```text
gemma4.context_length = 262144
```

Artinya model mendukung context length hingga **256K token**.

Jika file GGUF lama masih terbaca 131K, silakan unduh ulang versi terbaru.

---

## Cara Menjalankan

### Opsi A: llama.cpp

Pastikan menggunakan versi `llama.cpp` terbaru yang sudah mendukung arsitektur Gemma 4 unified.

Contoh file `.bat` untuk Windows:

```bat
@echo off
cd /d C:\llama.cpp

llama-server.exe ^
  -m C:\models\blueboop-jigsaw-Q4_K_M.gguf ^
  --ctx-size 16384 ^
  --n-gpu-layers 99 ^
  --no-mmap ^
  -fa on ^
  --cache-type-k q8_0 --cache-type-v q8_0 ^
  --temp 1.0 ^
  --top-p 0.95 ^
  --top-k 64 ^
  --host 0.0.0.0 ^
  --port 18080

pause
```

Lalu buka:

```text
http://localhost:18080
```

---

### Opsi B: llama.cpp CLI

```bash
./llama-cli \
  -m ./models/blueboop-jigsaw-Q4_K_M.gguf \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64
```

---

### Opsi C: LM Studio

Langkah penggunaan:

1. Buka LM Studio.
2. Import file GGUF.
3. Pilih quant yang ingin digunakan.
4. Gunakan template chat Gemma jika tersedia.
5. Jalankan model secara lokal.

---

### Opsi D: Ollama

Buat file bernama `Modelfile`:

```text
FROM ./blueboop-jigsaw-Q4_K_M.gguf

PARAMETER temperature 1.0
PARAMETER top_p 0.95
PARAMETER top_k 64
PARAMETER num_ctx 8192
```

Lalu jalankan:

```bash
ollama create blueboop-jigsaw -f Modelfile
ollama run blueboop-jigsaw
```

---

## Pengaturan Rekomendasi

### Untuk Chat Umum

| Parameter   |      Nilai Rekomendasi |
| ----------- | ---------------------: |
| Temperature |                    1.0 |
| Top P       |                   0.95 |
| Top K       |                     64 |
| Context     |          8K sampai 32K |
| KV cache    | q8_0 jika memori cukup |

### Untuk Coding

| Parameter      | Nilai Rekomendasi |
| -------------- | ----------------: |
| Temperature    |    0.0 sampai 0.4 |
| Top P          |   0.9 sampai 0.95 |
| Top K          |      40 sampai 64 |
| Context        |     8K sampai 64K |
| Repeat penalty |   Default runtime |

### Untuk Long Context

| Setting  | Rekomendasi                           |
| -------- | ------------------------------------- |
| Quant    | Q3_K_M atau Q4_K_M                    |
| KV cache | q4_0 atau q8_0                        |
| Context  | Mulai dari 32K, lalu naikkan bertahap |
| Hardware | 16 GB+ unified memory disarankan      |

---

## Thinking Mode

Blueboop Jigsaw dilatih agar dapat melakukan reasoning sebelum memberikan jawaban akhir.

Agar hasil lebih baik:

* Gunakan chat template Gemma.
* Aktifkan thinking mode jika runtime mendukung.
* Untuk coding, minta model menjelaskan pendekatan secara singkat sebelum menulis kode.
* Untuk hasil lebih deterministik, gunakan temperature rendah.

Contoh prompt:

```text
Selesaikan masalah Python berikut. Jelaskan pendekatan secara singkat, sebutkan edge case, lalu berikan kode yang bersih dan bisa dijalankan.
```

---

## Contoh Prompt

```text
Kamu adalah asisten coding. Selesaikan masalah berikut menggunakan Python.

Tugas:
Diberikan sebuah list integer, kembalikan panjang longest increasing subsequence.

Syarat:
- Jelaskan pendekatan secara singkat.
- Sertakan kompleksitas waktu dan memori.
- Berikan kode Python yang bersih.
```

---

## Contoh Output

```python
from bisect import bisect_left

def length_of_lis(nums):
    tails = []

    for num in nums:
        idx = bisect_left(tails, num)

        if idx == len(tails):
            tails.append(num)
        else:
            tails[idx] = num

    return len(tails)
```

Penjelasan singkat:

```text
Gunakan array tails, di mana tails[i] menyimpan nilai terkecil yang mungkin menjadi akhir subsequence naik dengan panjang i + 1.
Setiap angka ditempatkan menggunakan binary search. Kompleksitas waktunya O(n log n), dan kompleksitas memorinya O(n).
```

---

## Use Case

Model ini cocok untuk:

* Coding Python
* Latihan algoritma
* Competitive programming
* Debugging script kecil
* Penjelasan kode
* Refactoring kode sederhana
* Asisten coding lokal
* Pembelajaran pemrograman
* Eksperimen local LLM
* Eksperimen agentic coding ringan

---

## Keterbatasan

Blueboop Jigsaw adalah model yang difokuskan untuk coding. Model ini tidak disarankan dijadikan sumber utama untuk fakta umum atau keputusan penting.

Keterbatasan yang perlu diperhatikan:

* Paling kuat untuk Python dan coding algoritmik.
* Bisa lebih lemah untuk bahasa pemrograman selain Python.
* Bisa salah pada API, library, atau framework yang sangat spesifik.
* Bisa menghasilkan nama package, fungsi, atau konfigurasi yang tidak valid.
* Fakta umum tetap perlu diverifikasi.
* Performa long context sangat bergantung pada hardware dan runtime.
* Quant kecil dapat menurunkan kualitas reasoning.
* Belum safety-aligned untuk penggunaan produksi.

---

## Catatan Keamanan

Model ini memiliki perilaku refusal yang lebih rendah karena data training lebih fokus pada tugas coding.

Sebelum digunakan untuk produksi:

* Tambahkan guardrail sendiri.
* Selalu review kode yang dihasilkan.
* Jalankan test sebelum deploy.
* Jangan menjalankan script secara membabi buta.
* Validasi output untuk tugas keamanan, finansial, legal, atau sistem kritikal.
* Gunakan sandbox saat menjalankan kode yang belum diverifikasi.

---

## Preview Blueboop Jigsaw v2

Blueboop Jigsaw v2 direncanakan sebagai versi yang lebih kuat untuk agentic coding dan debugging.

Fokus v2:

* Agentic coding
* Terminal-style debugging
* Diagnose, fix, verify workflow
* Tool-use behavior
* Instruksi lebih konsisten
* Benchmark agentic lebih baik

Preview benchmark:

| Benchmark               | Base | v2 Preview |
| ----------------------- | ---: | ---------: |
| tau2-bench telecom Q8_0 | ~15% |       ~55% |

Detail benchmark lengkap sebaiknya ditulis di model card v2 setelah rilis.

---

## Safetensors Master

Versi full-precision safetensors tersedia di:

```text
dhafapermadi/blueboop-jigsaw-1.8
```

Gunakan versi safetensors jika ingin:

* Membuat GGUF quant sendiri.
* Membuat versi MLX.
* Membuat AWQ/GPTQ quant.
* Melanjutkan fine-tuning.
* Melakukan evaluasi custom.
* Mengembangkan model turunan.

---

## Base Model dan Lisensi

* Base model: `google/gemma-4-12B-it`
* Format model: GGUF
* Lisensi: Apache 2.0
* Fine-tune license: Apache 2.0
* Penggunaan: riset, eksperimen, local coding assistant, dan workflow pengembangan

Model ini dibagikan apa adanya tanpa garansi.

---

## Citation

Jika menggunakan model ini, bisa mencantumkan citation berikut:

```bibtex
@misc{blueboop_jigsaw_gguf,
  title        = {Blueboop Jigsaw GGUF},
  author       = {Dhafa Nazula Permadi},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/dhafapermadi/blueboop-jigsaw-gguf}},
  note         = {Local coding reasoning model based on Gemma 4 12B}
}
```

---

## Rekomendasi Akhir

Untuk pemakaian umum:

```text
Q4_K_M + llama.cpp + context 8K sampai 16K
```

Untuk kualitas lebih tinggi:

```text
Q6_K atau Q8_0 + context lebih besar + temperature rendah untuk coding
```

Untuk perangkat terbatas:

```text
Q2_K atau Q3_K_M + context kecil + KV cache ringan
```

Blueboop Jigsaw dibuat untuk pengguna yang ingin memiliki asisten coding lokal, privat, ringan, dan bebas dari ketergantungan API cloud.