Open-Source Models

Alongside its own models, Sarvam serves a small set of open-source models. You reach them through the same chat completions API, with the same API key, credits, and rate limits — only the model field changes.

Available models

Capabilities at a glance

For comparison, Sarvam’s flagship chat model sarvam-105b supports tool calling with 128K context and is tuned for 23 languages (22 Indian + English).

Using an open-source model

Open-source models are served on /v2/chat/completions. The same endpoint also accepts sarvam-105b. Sarvam chat models — including sarvam-105b-conversations — are on /v1; /v1 does not accept glm5.2 or gemma4.

Authentication uses the api-subscription-key header. A missing or invalid key is refused with 403 invalid_api_key_error. GET /v2/models and GET /v2/models/{model_id} are unauthenticated and list only the models available to you.

Use the Sarvam SDK — client.open_source_models.chat_completions_v2(...) in Python, or client.openSourceModels.chatCompletionsV2(...) in JavaScript.

1
from sarvamai import SarvamAI
2
3
client = SarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
4
5
response = client.open_source_models.chat_completions_v2(
6
    model="glm5.2",
7
    messages=[
8
        {"role": "user", "content": "Summarise the causes of the 2008 financial crisis."}
9
    ],
10
    temperature=0.2,
11
    max_tokens=1000,
12
)
13
14
print(response.choices[0].message.content)

Model selection

In most cases the answer is a Sarvam model — reach for an open-source model only when you need a capability Sarvam’s own models do not have.

Supported parameters

These models accept the same OpenAI-compatible parameters as Sarvam’s chat models, with the exceptions called out below. Support differs per model where the model itself lacks the capability.

Full request and response schema: Open-Source Models API Reference.

Reasoning output

glm5.2 is a reasoning model: it thinks before every answer, whether or not reasoning_effort is set. The chain-of-thought arrives in a separate reasoning_content field on the message — content holds only the final answer — and in streaming responses it arrives as delta.reasoning_content chunks before the answer starts. Reasoning tokens are billed as completion tokens and count against max_tokens, so a budget that is too small is consumed entirely by reasoning and the request returns content: null with finish_reason: "length".

To turn reasoning off — faster, cheaper, and the whole budget goes to the answer — send the thinking switch through extra_body:

1
{
2
  "extra_body": {
3
    "chat_template_kwargs": { "enable_thinking": false }
4
  }
5
}

gemma4 is not a reasoning model. It answers directly, never returns reasoning_content, and setting reasoning_effort on it has no effect.

Structured Outputs

response_format works on both models. Use {"type": "json_schema", "json_schema": {...}} to constrain output to a JSON Schema, or {"type": "json_object"} for the older JSON mode, which guarantees valid JSON but not a specific shape.

1
import json
2
3
from sarvamai import SarvamAI
4
5
client = SarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
6
7
response = client.open_source_models.chat_completions_v2(
8
    model="glm5.2",
9
    messages=[
10
        {"role": "user", "content": "List two Indian cities with their populations."}
11
    ],
12
    max_tokens=500,
13
    extra_body={
14
        "chat_template_kwargs": {"enable_thinking": False}
15
    },
16
    response_format={
17
        "type": "json_schema",
18
        "json_schema": {
19
            "name": "city_list",
20
            "strict": True,
21
            "schema": {
22
                "type": "object",
23
                "properties": {
24
                    "cities": {
25
                        "type": "array",
26
                        "items": {
27
                            "type": "object",
28
                            "properties": {
29
                                "name": {"type": "string"},
30
                                "population": {"type": "integer"},
31
                            },
32
                            "required": ["name", "population"],
33
                            "additionalProperties": False,
34
                        },
35
                    }
36
                },
37
                "required": ["cities"],
38
                "additionalProperties": False,
39
            },
40
        },
41
    },
42
)
43
44
cities = json.loads(response.choices[0].message.content)
45
print(cities)

Image input

Only gemma4 accepts images, and only as base64 data URIs. A remote http:// or https:// URL is rejected — the API does not fetch images on your behalf. Full example on the Gemma 4 31B page.

1
{
2
  "type": "image_url",
3
  "image_url": { "url": "data:image/png;base64,<encoded bytes>" }
4
}

Each image counts against the request-size cap once encoded. Prompt and request-size checks use estimates — text at roughly 4 bytes per token, plus a flat per-image allowance — rather than an exact tokenizer count.

Tool schemas

function.parameters must be a JSON Schema object; a property defined as a bare string is rejected. When tool_choice forces a call (required or a named function), schemas must be self-contained: non-local $ref, unresolved $ref, recursive schemas, or a combined expansion above 20,000 nodes across all tools in the request are rejected with 400.

Errors

Every error uses the same envelope — error.message, error.code, and error.request_id (empty when the error is raised before a request id is assigned):

1
{
2
  "error": {
3
    "message": "Model 'gpt-4' not found.",
4
    "code": "not_found_error",
5
    "request_id": "20260729_0f1e2d3c-…"
6
  }
7
}

Timeouts, connection failures, and overload are retried automatically before a 503 is returned. A request the model itself rejects is not retried and comes back as 422.

Support and expectations

Shared behaviour

Everything below applies to both models:

• Endpoint — POST https://api.sarvam.ai/v2/chat/completions. Full parameter reference: Open-Source Models API Reference.
• Model discovery — GET https://api.sarvam.ai/v2/models lists the model IDs the endpoint currently serves.
• Authentication — api-subscription-key: sk_xxx. Invalid keys return 403 invalid_api_key_error. See Authentication.
• Beta access — granted per key. Without access, the endpoint returns 400 invalid_request_error before calling the model. See Access to Beta APIs.
• Streaming — set "stream": true for server-sent events.
• Billing — metered per token against your Sarvam credits, reasoning tokens included. Per 1M tokens (input / cached input / output): gemma4 ₹36.6 / ₹13.73 / ₹91.5, glm5.2 ₹128.1 / ₹23.79 / ₹402.6. The two are not priced alike — glm5.2 costs roughly 3.5× gemma4, and it reasons before every answer, so budget max_tokens deliberately. See Pricing.
• Rate limits — applied per API key. See Credits & Rate Limits.