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 models also accept the OpenAI Responses protocol at POST /v2/responses. The chat endpoint also accepts sarvam-105b. Sarvam chat models — including sarvam-105b-conversations — are on /v1; /v1 does not accept glm5.3, gemma4, or deepseekv4-flash.

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.

from sarvamai import SarvamAI
client = SarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
response = client.open_source_models.chat_completions_v2(
    model="glm5.3",
    messages=[
        {"role": "user", "content": "Summarise the causes of the 2008 financial crisis."}
    ],
    temperature=0.2,
    max_tokens=1000,
)
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.3 and deepseekv4-flash are reasoning models: they think 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".

Reasoning tokens are reported on usage.completion_tokens_details.reasoning_tokens (and, with stream_options.include_usage, on a later streaming chunk).

extra_body.chat_template_kwargs.enable_thinking: false is accepted but currently does not disable thinking on glm5.3. Use reasoning_effort: "low" to keep the trace short, or raise max_tokens so reasoning cannot consume the whole budget. On POST /v2/responses, text.format of json_object or json_schema skips the reasoning item.

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 all three 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.

import json
from sarvamai import SarvamAI
client = SarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
response = client.open_source_models.chat_completions_v2(
    model="glm5.3",
    messages=[
        {"role": "user", "content": "List two Indian cities with their populations."}
    ],
    max_tokens=500,
    extra_body={
        "chat_template_kwargs": {"enable_thinking": False}
    },
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "city_list",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "cities": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "population": {"type": "integer"},
                            },
                            "required": ["name", "population"],
                            "additionalProperties": False,
                        },
                    }
                },
                "required": ["cities"],
                "additionalProperties": False,
            },
        },
    },
)
cities = json.loads(response.choices[0].message.content)
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.

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

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):

{
  "error": {
    "message": "Model 'gpt-4' not found.",
    "code": "not_found_error",
    "request_id": "20260729_0f1e2d3c-…"
  }
}

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. The same models also accept the OpenAI Responses protocol at POST /v2/responses. Create-only and stateless: replay input every turn. Omit store or pass false (OpenAI SDKs default true — that call is 400).
• 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. Chat still sends [DONE]; Responses does not. Pass chat stream_options.include_usage for a usage chunk. Responses tool/reasoning streams use response.function_call_arguments.* and response.reasoning_text.*.
• 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, deepseekv4-flash ₹19.8 / ₹0.63 / ₹59.4, glm5.3 ₹126 / ₹23.4 / ₹396. The three are not priced alike — glm5.3 and deepseekv4-flash reason before every answer, so budget max_tokens deliberately, and glm5.3 costs roughly 6× deepseekv4-flash. See Pricing.
• Rate limits — applied per API key. See Credits & Rate Limits.