Gunakan Groq GPT-OSS 120B dengan OpenAI SDK: Base URL, Harga, dan Caching

Endpoint Groq yang kompatibel dengan OpenAI benar-benar bisa diganti dengan satu baris: set base_url ke https://api.groq.com/openai/v1 dan tetap gunakan OpenAI SDK. Per 17 Juni 2026, Groq mencantumkan openai/gpt-oss-120b seharga $0.15 per 1 juta token input tanpa cache, $0.075 per 1 juta token input yang di-cache, dan $0.60 per 1 juta token output di halaman harganya (Harga Groq).

Itulah bagian yang berguna. Jebakannya adalah menganggap “kompatibel dengan OpenAI” berarti “perilaku identik dan penagihan identik.” Tidak begitu. Anda tetap perlu memilih ID model Groq, memantau cache hit, menghindari parameter OpenAI yang tidak didukung, dan menghitung panggilan tool bawaan secara terpisah.

Apa yang Sebenarnya Anda Ganti

Dokumentasi Groq menyebut API-nya “sebagian besar kompatibel dengan pustaka klien OpenAI” dan menunjukkan konfigurasi klien OpenAI yang persis: berikan kunci Groq Anda dan set base_url="https://api.groq.com/openai/v1" (Kompatibilitas OpenAI Groq).

Instal OpenAI Python SDK:

pip install openai
export GROQ_API_KEY="gsk_..."

Lalu panggil GPT-OSS 120B melalui Groq:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a concise senior backend engineer."},
        {"role": "user", "content": "Write a PostgreSQL index plan for a slow user_events query."},
    ],
)

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

Perbedaan pentingnya ada pada model. Di platform OpenAI sendiri, Anda mungkin menggunakan nama model yang di-host oleh OpenAI. Di Groq, GPT-OSS diakses sebagai openai/gpt-oss-120b atau openai/gpt-oss-20b.

OpenAI merilis gpt-oss-120b dan gpt-oss-20b pada 5 Agustus 2025 sebagai model reasoning berbobot terbuka di bawah Apache 2.0 (OpenAI). OpenAI menyebut gpt-oss-120b memiliki total 117B parameter, 5.1B parameter aktif per token, 128 expert, 4 expert aktif per token, dan dukungan native untuk panjang konteks hingga 128k (OpenAI). Halaman model Groq mencantumkan context window openai/gpt-oss-120b yang di-host sebesar 131.072 token dan token output maksimum 65.536 (kartu model Groq).

Pilih 120B atau 20B

Gunakan 120B ketika kualitas lebih penting daripada biaya mentah: perencanaan agent, tugas coding yang lebih sulit, ekstraksi kompleks, atau reasoning multi-langkah. Gunakan 20B ketika Anda membutuhkan throughput yang lebih murah untuk routing, peringkasan, klasifikasi, asisten singkat, atau job background bervolume tinggi.

ID model Groq	Kecepatan tercantum	Input tanpa cache	Input cache	Output
openai/gpt-oss-120b	500 TPS	$0.15 / 1M	$0.075 / 1M	$0.60 / 1M
openai/gpt-oss-20b	1,000 TPS	$0.075 / 1M	$0.0375 / 1M	$0.30 / 1M

Harga tersebut berasal dari tabel harga dan tabel prompt caching Groq saat ini (Harga Groq). Model 20B tepat setengah dari harga token 120B yang tercantum. Ini menjadikannya default yang bagus untuk workflow “coba dulu”. Jika kualitas jawaban belum cukup baik, naikkan path tersebut ke 120B.

Berikut switch kecil yang bisa Anda simpan di konfigurasi:

import os
from openai import OpenAI

MODEL = os.getenv("GROQ_MODEL", "openai/gpt-oss-20b")

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

def ask(prompt: str) -> str:
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": "Answer with practical developer steps."},
            {"role": "user", "content": prompt},
        ],
    )
    return response.choices[0].message.content

print(ask("Give me a minimal Redis rate limiter design."))

Jalankan dengan 20B:

GROQ_MODEL=openai/gpt-oss-20b python app.py

Jalankan dengan 120B:

GROQ_MODEL=openai/gpt-oss-120b python app.py

Hitung Harga Request dengan Cache Hit

Prompt caching Groq bersifat otomatis untuk model yang didukung, termasuk openai/gpt-oss-20b dan openai/gpt-oss-120b. Groq mengatakan tidak diperlukan perubahan kode, cache hit menggunakan pencocokan prefix persis, bagian yang di-cache mendapat diskon token input 50%, dan data cache kedaluwarsa otomatis setelah 2 jam tanpa penggunaan (Prompt Caching Groq).

Aturan praktisnya: letakkan teks stabil di awal.

Urutan yang baik:

1. System prompt
2. Definisi tool
3. Contoh few-shot
4. Dokumen atau skema bersama
5. Input spesifik pengguna
6. Timestamp, ID, data per request

Urutan buruk: meletakkan timestamp, request ID, atau field spesifik pengguna sebelum prompt bersama sepanjang 20.000 token. Itu merusak prefix.

Berikut helper biaya untuk GPT-OSS 120B:

def groq_gpt_oss_120b_cost(prompt_tokens, cached_tokens, completion_tokens):
    uncached_tokens = max(prompt_tokens - cached_tokens, 0)

    return (
        uncached_tokens / 1_000_000 * 0.15
        + cached_tokens / 1_000_000 * 0.075
        + completion_tokens / 1_000_000 * 0.60
    )

Dan berikut panggilan yang bisa dijalankan untuk mencetak penggunaan cache jika Groq mengembalikannya:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

STATIC_POLICY = """
You are an internal code review assistant.
Always check correctness, security, performance, and migration risk.
Return JSON with keys: summary, risks, suggested_patch.
"""

def review(diff: str):
    response = client.chat.completions.create(
        model="openai/gpt-oss-120b",
        messages=[
            {"role": "system", "content": STATIC_POLICY},
            {"role": "user", "content": diff},
        ],
        response_format={"type": "json_object"},
    )

    usage = response.usage
    details = getattr(usage, "prompt_tokens_details", None)
    cached = getattr(details, "cached_tokens", 0) if details else 0

    print("prompt_tokens:", usage.prompt_tokens)
    print("cached_tokens:", cached)
    print("completion_tokens:", usage.completion_tokens)
    print("estimated_cost_usd:", groq_gpt_oss_120b_cost(
        usage.prompt_tokens,
        cached,
        usage.completion_tokens,
    ))

    return response.choices[0].message.content

Dokumentasi caching Groq menunjukkan cached_tokens di bawah usage.prompt_tokens_details dan mendefinisikan cache hit rate sebagai cached_tokens / prompt_tokens × 100% (Prompt Caching Groq). Jangan berasumsi setiap request kedua akan lebih murah. Prefix persis itu penting.

Hitung Panggilan Tool Secara Terpisah

Harga token bukan seluruh tagihan jika Anda mengaktifkan tool bawaan. Halaman harga Groq mencantumkan Built-In Tools untuk GPT-OSS secara terpisah: Browser Search basic search seharga $5 / 1000 request, Browser Search visit website seharga $1 / 1000 request, dan Code Execution Python seharga $0.18 / jam (Harga Groq).

Ini mengubah cara Anda mendesain agent. Bot dukungan yang memanggil pencarian sekali per pesan pengguna memiliki bentuk biaya yang berbeda dari peringkas yang hanya menggunakan token prompt. Cache membantu untuk skema tool berulang, tetapi tidak membuat panggilan tool eksternal menjadi gratis.

Periksa juga kompatibilitas sebelum menyalin-tempel kode OpenAI. Dokumentasi kompatibilitas OpenAI Groq mencantumkan field yang tidak didukung dan dapat mengembalikan 400, termasuk logprobs, logit_bias, top_logprobs, messages[].name, dan nilai n selain 1 (Kompatibilitas OpenAI Groq). Groq juga mengatakan temperature=0 dikonversi menjadi 1e-8.

Request minimal yang aman terlihat seperti ini:

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    temperature=0.2,
    messages=[
        {"role": "system", "content": "Be precise. If unsure, say so."},
        {"role": "user", "content": "Explain this stack trace and suggest a fix: ..."},
    ],
)

Hindari memigrasikan seluruh aplikasi dalam satu commit. Letakkan pengaturan provider di balik environment variable:

LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_API_KEY=$GROQ_API_KEY
LLM_MODEL=openai/gpt-oss-120b

Lalu hubungkan ke SDK:

client = OpenAI(
    api_key=os.environ["LLM_API_KEY"],
    base_url=os.environ["LLM_BASE_URL"],
)

response = client.chat.completions.create(
    model=os.environ["LLM_MODEL"],
    messages=[{"role": "user", "content": "Summarize this incident report."}],
)

Escape Hatch Multi-Provider yang Praktis

Jika Anda menghubungkan ini ke production, jangan hard-code asumsi provider di seluruh codebase. Simpan base_url, api_key, dan model di konfigurasi. Itu membuat Groq mudah diuji, dan juga membuat provider routing menjadi membosankan.

Untuk tim yang menginginkan satu endpoint kompatibel OpenAI untuk Claude, GPT, dan Gemini, onehop adalah jalur yang mudah: ubah base URL ke https://api.onehop.ai/v1. Ini kompatibel dengan OpenAI/Anthropic, harganya lebih murah daripada first-party, dan akun baru mendapat gratis $10 tanpa perlu kartu.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ONEHOP_API_KEY"],
    base_url="https://api.onehop.ai/v1",
)

response = client.chat.completions.create(
    model=os.environ["ONEHOP_MODEL"],
    messages=[
        {"role": "user", "content": "Compare this API design against common REST mistakes."}
    ],
)

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

Gunakan Groq ketika Anda secara spesifik menginginkan inferensi GPT-OSS yang cepat dan stack tool/caching Groq. Gunakan onehop ketika Anda menginginkan satu permukaan integrasi lintas Claude, GPT, Gemini, dan model hosted lain tanpa menulis ulang kode klien. Anda bisa memanggil Claude dan model lain di onehop atau mendaftar untuk kredit gratis $10.

Checklist Production

Sebelum rilis, jalankan checklist ini:

• Pin ID model: openai/gpt-oss-120b untuk kualitas, openai/gpt-oss-20b untuk biaya lebih rendah.
• Letakkan bagian prompt yang stabil di awal agar Groq dapat menggunakan ulang prefix yang di-cache.
• Log prompt_tokens, cached_tokens, dan completion_tokens untuk setiap request.
• Tambahkan akuntansi terpisah untuk Browser Search, Visit Website, dan Code Execution.
• Hapus parameter OpenAI yang tidak didukung sebelum mengarahkan traffic ke Groq.
• Jaga base_url tetap dapat dikonfigurasi agar Anda bisa menguji Groq, API first-party, atau onehop tanpa menyentuh business logic.

Seluruh migrasi bisa berupa satu baris. Migrasi yang andal adalah tiga baris plus akuntansi: base URL, ID model, dan telemetri biaya. Mulai dari sana, lalu putuskan apakah kualitas 120B sepadan dengan pengeluaran token output untuk setiap path di aplikasi Anda. Jika Anda menginginkan pola base-URL yang sama untuk akses model yang lebih luas, panggil Claude dan model lain di onehop dan daftar untuk kredit gratis $10.