OpenAI SDK के साथ Groq GPT-OSS 120B इस्तेमाल करें: Base URL, Pricing और Caching

Groq का OpenAI-compatible endpoint सच में एक one-line swap है: base_url को https://api.groq.com/openai/v1 पर set करें और OpenAI SDK का इस्तेमाल जारी रखें। 17 जून, 2026 तक, Groq अपनी pricing page पर openai/gpt-oss-120b को $0.15 per 1M uncached input tokens, $0.075 per 1M cached input tokens, और $0.60 per 1M output tokens के रूप में list करता है (Groq Pricing).

यही उपयोगी हिस्सा है। जाल यह मान लेना है कि “OpenAI-compatible” का मतलब “identical behavior और identical billing” है। ऐसा नहीं है। आपको फिर भी Groq model ID चुननी होगी, cache hits पर नज़र रखनी होगी, unsupported OpenAI parameters से बचना होगा, और built-in tool calls को अलग से count करना होगा।

आप असल में क्या बदल रहे हैं

Groq के docs कहते हैं कि इसकी API “mostly compatible with OpenAI’s client libraries” है और exact OpenAI client configuration दिखाते हैं: अपनी Groq key pass करें और base_url="https://api.groq.com/openai/v1" set करें (Groq OpenAI Compatibility).

OpenAI Python SDK install करें:

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

फिर Groq के ज़रिए GPT-OSS 120B call करें:

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)

महत्वपूर्ण अंतर model है। OpenAI के अपने platform पर आप OpenAI-hosted model name इस्तेमाल कर सकते हैं। Groq पर, GPT-OSS को openai/gpt-oss-120b या openai/gpt-oss-20b के रूप में address किया जाता है।

OpenAI ने 5 अगस्त, 2025 को Apache 2.0 के तहत open-weight reasoning models के रूप में gpt-oss-120b और gpt-oss-20b release किए (OpenAI). OpenAI कहता है कि gpt-oss-120b में 117B total parameters, प्रति token 5.1B active parameters, 128 experts, प्रति token 4 active experts, और 128k तक की context lengths के लिए native support है (OpenAI). Groq की model page hosted openai/gpt-oss-120b context window को 131,072 tokens और max output tokens को 65,536 के रूप में list करती है (Groq model card).

120B या 20B चुनें

जब quality raw cost से ज़्यादा मायने रखती हो तब 120B इस्तेमाल करें: agent planning, कठिन coding tasks, complex extraction, या multi-step reasoning। जब आपको routing, summarization, classification, short assistants, या high-volume background jobs के लिए सस्ता throughput चाहिए तब 20B इस्तेमाल करें।

Groq model ID	Listed speed	Uncached input	Cached input	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

ये prices Groq की current pricing table और prompt caching table से आते हैं (Groq Pricing). 20B model, 120B की listed token price का ठीक आधा है। इसलिए यह “try it first” workflows के लिए अच्छा default बनता है। अगर answer quality पर्याप्त अच्छी न हो, तो उस path को 120B पर promote करें।

यह एक छोटा switch है जिसे आप config में रख सकते हैं:

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."))

इसे 20B के साथ run करें:

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

इसे 120B के साथ run करें:

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

Cache Hits के साथ requests की कीमत निकालें

Groq prompt caching supported models के लिए automatic है, जिनमें openai/gpt-oss-20b और openai/gpt-oss-120b शामिल हैं। Groq कहता है कि code changes की ज़रूरत नहीं है, cache hits exact prefix matching इस्तेमाल करते हैं, cached portions को 50% input-token discount मिलता है, और cached data बिना उपयोग के 2 घंटे बाद automatically expire हो जाता है (Groq Prompt Caching).

Practical rule: stable text को पहले रखें।

अच्छा order:

1. System prompt
2. Tool definitions
3. Few-shot examples
4. Shared documents या schemas
5. User-specific input
6. Timestamps, IDs, per-request data

खराब order: 20,000-token shared prompt से पहले timestamp, request ID, या user-specific field रखना। इससे prefix टूट जाता है।

GPT-OSS 120B के लिए cost helper यहाँ है:

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
    )

और यहाँ एक runnable call है जो Groq के return करने पर cache usage print करता है:

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

Groq के caching docs usage.prompt_tokens_details के तहत cached_tokens दिखाते हैं और cache hit rate को cached_tokens / prompt_tokens × 100% के रूप में define करते हैं (Groq Prompt Caching). यह assume न करें कि हर दूसरी request सस्ती होगी। Exact prefixes मायने रखते हैं।

Tool Calls को अलग से count करें

अगर आप built-in tools enable करते हैं, तो token prices पूरी bill नहीं होतीं। Groq की pricing page GPT-OSS के लिए Built-In Tools को अलग से list करती है: Browser Search basic search $5 / 1000 requests, Browser Search visit website $1 / 1000 requests, और Code Execution Python $0.18 / hour है (Groq Pricing).

इससे agents design करने का तरीका बदल जाता है। एक support bot जो हर user message पर एक बार search call करता है, उसकी cost shape उस summarizer से अलग होती है जो केवल prompt tokens इस्तेमाल करता है। Cache repeated tool schemas में मदद करता है, लेकिन यह external tool calls को free नहीं बनाता।

OpenAI code copy-paste करने से पहले compatibility भी check करें। Groq के OpenAI compatibility docs unsupported fields list करते हैं जो 400 return कर सकते हैं, जिनमें logprobs, logit_bias, top_logprobs, messages[].name, और 1 के अलावा n values शामिल हैं (Groq OpenAI Compatibility). Groq यह भी कहता है कि temperature=0 को 1e-8 में convert किया जाता है।

एक safe minimal request ऐसी दिखती है:

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: ..."},
    ],
)

अपनी पूरी app को एक commit में migrate करने से बचें। Provider settings को environment variables के पीछे रखें:

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

फिर उन्हें SDK में wire करें:

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."}],
)

एक Practical Multi-Provider Escape Hatch

अगर आप इसे production में wire कर रहे हैं, तो provider assumptions को अपने codebase में हर जगह hard-code न करें। base_url, api_key, और model को config में रखें। इससे Groq test करना आसान होता है, और provider routing भी boring हो जाती है।

जो teams Claude, GPT, और Gemini के लिए एक OpenAI-compatible endpoint चाहती हैं, उनके लिए onehop आसान रास्ता है: base URL को https://api.onehop.ai/v1 में बदल दें। यह OpenAI/Anthropic compatible है, first-party से सस्ता priced है, और नए accounts को बिना card के $10 free मिलते हैं।

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)

जब आपको specifically fast GPT-OSS inference और Groq का tool/caching stack चाहिए तब Groq इस्तेमाल करें। जब आप client code rewrite किए बिना Claude, GPT, Gemini, और अन्य hosted models में single integration surface चाहते हैं तब onehop इस्तेमाल करें। आप onehop पर Claude और अन्य models call कर सकते हैं या $10 free credit के लिए sign up कर सकते हैं।

Production Checklist

Ship करने से पहले, यह checklist run करें:

• Model ID pin करें: quality के लिए openai/gpt-oss-120b, कम cost के लिए openai/gpt-oss-20b।
• Stable prompt sections को पहले रखें ताकि Groq cached prefixes reuse कर सके।
• हर request के लिए prompt_tokens, cached_tokens, और completion_tokens log करें।
• Browser Search, Visit Website, और Code Execution के लिए separate accounting जोड़ें।
• Groq पर traffic route करने से पहले unsupported OpenAI parameters हटाएँ।
• base_url configurable रखें ताकि आप business logic छुए बिना Groq, first-party APIs, या onehop test कर सकें।

पूरी migration एक line की हो सकती है। Reliable migration तीन lines plus accounting है: base URL, model ID, और cost telemetry। वहीं से शुरू करें, फिर तय करें कि आपकी app के हर path के लिए 120B की quality output-token spend के लायक है या नहीं। अगर आप broader model access के लिए वही base-URL pattern चाहते हैं, तो onehop पर Claude और अन्य models call करें और $10 free credit के लिए sign up करें।