---
updatedAt: 2026-10-15T16:11:26.000Z
---

# Creates a model response for the given chat conversation.

Given a list of messages comprising a conversation, the model will return a response. Compatible with OpenAI. See https://platform.openai.com/docs/api-reference/chat/create

# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "NVIDIA NIM API for nvidia/nemotron-3.5-super-vl-120b-a12b",
    "description": "The NVIDIA NIM REST API. Please see https://docs.api.nvidia.com/nim/reference/nvidia-nemotron-3.5-super for more details.",
    "version": "1.0.0",
    "termsOfService": "https://www.nvidia.com/en-us/data-center/products/nvidia-ai-enterprise/eula/",
    "contact": {
      "name": "NVIDIA Enterprise Support",
      "url": "https://www.nvidia.com/en-us/support/enterprise/"
    },
    "license": {
      "name": "NVIDIA Nemotron Open Model License",
      "url": "https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-nemotron-open-model-license/"
    }
  },
  "servers": [
    {
      "url": "https://integrate.api.nvidia.com/v1/"
    }
  ],
  "paths": {
    "/chat/completions": {
      "post": {
        "operationId": "nvidia-nemotron-3_5-super-vl-120b-a12b-infer",
        "tags": [
          "Chat"
        ],
        "summary": "Creates a model response for the given chat conversation.",
        "description": "Given a list of messages comprising a conversation, the model will return a response. Compatible with OpenAI. See https://platform.openai.com/docs/api-reference/chat/create",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ChatRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Invocation is fulfilled",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ChatCompletion"
                }
              },
              "text/event-stream": {
                "schema": {
                  "$ref": "#/components/schemas/ChatCompletionChunk"
                }
              }
            }
          },
          "202": {
            "description": "Result is pending. Client should poll using the requestId.",
            "content": {
              "application/json": {
                "example": {},
                "schema": {}
              }
            },
            "headers": {
              "NVCF-REQID": {
                "description": "requestId required for pooling",
                "schema": {
                  "type": "string",
                  "format": "uuid"
                }
              },
              "NVCF-STATUS": {
                "description": "Invocation status",
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "400": {
            "description": "Invalid request parameters, model alias, or messages.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ValidationError"
                },
                "example": {
                  "message": "The 'messages' field cannot be empty.",
                  "type": "Bad Request",
                  "code": 400
                }
              }
            }
          },
          "422": {
            "description": "Validation failed, provided entity could not be processed.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                },
                "example": {
                  "type": "urn:nvcf-worker-service:problem-details:unprocessable-entity",
                  "title": "Unprocessable Entity",
                  "status": 422,
                  "detail": "string",
                  "instance": "/v2/nvcf/pexec/functions/4a58c6cb-a9b4-4014-99de-3e704d4ae687",
                  "requestId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
                }
              }
            }
          },
          "500": {
            "description": "The invocation ended with an error.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Errors"
                },
                "example": {
                  "type": "urn:nvcf-worker-service:problem-details:internal-server-error",
                  "title": "Internal Server Error",
                  "status": 500,
                  "detail": "string",
                  "instance": "/v2/nvcf/pexec/functions/4a58c6cb-a9b4-4014-99de-3e704d4ae687",
                  "requestId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
                }
              }
            }
          }
        },
        "x-nvai-meta": {
          "name": "Create chat completion",
          "returns": "Returns a [chat completion](/docs/api-reference/chat/object) object, or a streamed sequence of [chat completion chunk](/docs/api-reference/chat/streaming) objects if the request is streamed.\n",
          "path": "create",
          "examples": [
            {
              "name": "Read the traffic sign in this image.",
              "input": {
                "text": "Read the traffic sign in this image. What does it say, and what color is the sign?",
                "images": [
                  "https://assets.ngc.nvidia.com/products/api-catalog/phi-3-5-vision/example1a.jpg"
                ]
              },
              "output": {
                "text": "The red traffic sign says STOP."
              },
              "requestJson": "{\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": [\n        {\n          \"type\": \"text\",\n          \"text\": <%- JSON.stringify(input.text) %>\n        },\n        {\n          \"type\": \"image_url\",\n          \"image_url\": {\n            \"url\": <%- JSON.stringify(input.images[0]) %>\n          }\n        }\n      ]\n    }\n  ],\n  \"temperature\": 1,\n  \"top_p\": 0.95,\n  \"max_tokens\": 2048,\n  \"seed\": 42,\n  \"stream\": true,\n  \"reasoning_effort\": \"none\"\n}\n",
              "responseJson": "{\n  \"id\": \"chatcmpl-example\",\n  \"object\": \"chat.completion\",\n  \"created\": 1677652288,\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"The red traffic sign says STOP.\"\n      },\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 256,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 264\n  }\n}\n"
            },
            {
              "name": "Which number is larger, 9.11 or 9.8?",
              "requestJson": "{\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"Which number is larger, 9.11 or 9.8?\"\n    }\n  ],\n  \"temperature\": 1.0,\n  \"top_p\": 0.95,\n  \"max_tokens\": 8192,\n  \"seed\": 42,\n  \"stream\": true,\n  \"reasoning_effort\": \"high\"\n}\n",
              "responseJson": "{\n  \"id\": \"id-123\",\n  \"object\": \"chat.completion\",\n  \"created\": 1677652288,\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"system_fingerprint\": \"fp_44709d6fcb\",\n  \"choices\": [{\n    \"index\": 0,\n    \"message\": {\n      \"role\": \"assistant\",\n      \"content\": \"The number 9.8 is larger...\"\n    },\n    \"finish_reason\": \"stop\"\n  }],\n  \"usage\": {\n    \"prompt_tokens\": 9,\n    \"completion_tokens\": 12,\n    \"total_tokens\": 21\n  }\n}\n"
            },
            {
              "name": "Summarize why GPU acceleration matters for deep learning in three concise bullet points.",
              "requestJson": "{\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"messages\": [\n    {\n      \"role\": \"user\",\n      \"content\": \"Summarize why GPU acceleration matters for deep learning in three concise bullet points.\"\n    }\n  ],\n  \"temperature\": 1.0,\n  \"top_p\": 0.95,\n  \"max_tokens\": 8192,\n  \"seed\": 42,\n  \"stream\": true,\n  \"reasoning_effort\": \"low\"\n}\n",
              "responseJson": "{\n  \"id\": \"id-123\",\n  \"object\": \"chat.completion\",\n  \"created\": 1677652288,\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"system_fingerprint\": \"fp_44709d6fcb\",\n  \"choices\": [{\n    \"index\": 0,\n    \"message\": {\n      \"role\": \"assistant\",\n      \"content\": \"- GPUs accelerate matrix operations that dominate deep learning workloads.\\n- Faster training shortens experimentation cycles and improves researcher productivity.\\n- High parallelism makes large-model inference and serving more practical at scale.\"\n    },\n    \"finish_reason\": \"stop\"\n  }],\n  \"usage\": {\n    \"prompt_tokens\": 9,\n    \"completion_tokens\": 12,\n    \"total_tokens\": 21\n  }\n}\n"
            }
          ],
          "templates": [
            {
              "title": "No Streaming",
              "requestEjs": {
                "python": "import os\nfrom openai import OpenAI\n\nclient = OpenAI(\n  base_url = \"https://integrate.api.nvidia.com/v1\",\n  api_key = os.environ[\"NVIDIA_API_KEY\"]\n)\n<%\n\nconst py_repr = (value) => {\n  if (value === null || value === undefined) return \"None\";\n  if (typeof value === \"boolean\") return value ? \"True\" : \"False\";\n  if (typeof value === \"string\") return JSON.stringify(value);\n  if (Array.isArray(value)) return \"[\" + value.map(py_repr).join(\", \") + \"]\";\n  if (typeof value === \"object\") return \"{\" + Object.entries(value).map(([key, item]) => JSON.stringify(key) + \": \" + py_repr(item)).join(\", \") + \"}\";\n  return String(value);\n};\nconst extra_body = {};\nconst reasoning_effort = request.reasoning_effort || \"high\";\nif (request.chat_template_kwargs) {\n  extra_body[\"chat_template_kwargs\"] = request.chat_template_kwargs;\n} else if (reasoning_effort === \"none\") {\n  extra_body[\"chat_template_kwargs\"] = {\"enable_thinking\": false};\n} else if (reasoning_effort === \"low\") {\n  extra_body[\"chat_template_kwargs\"] = {\"enable_thinking\": true, \"low_effort\": true};\n} else {\n  extra_body[\"chat_template_kwargs\"] = {\"enable_thinking\": true};\n}\nconst reasoning_enabled = !!(extra_body[\"chat_template_kwargs\"] &&\n  extra_body[\"chat_template_kwargs\"][\"enable_thinking\"]);\nconst extra_body_py = Object.keys(extra_body).length ? py_repr(extra_body) : null;\n%>\n<% if (request.tools) { %>\ncompletion = client.chat.completions.create(\n  model=\"<%- request.model %>\",\n  messages=<%- py_repr(request.messages) %>,\n  temperature=<%- request.temperature %>,\n  top_p=<%- request.top_p %>,\n  max_tokens=<%- request.max_tokens %>,\n<% if (request.parallel_tool_calls !== undefined) { %>\n  parallel_tool_calls=<%- py_repr(request.parallel_tool_calls) %>,<% } %>\n<% if (request.stream_options) { %>\n  stream_options=<%- py_repr(request.stream_options) %>,<% } %>\n<% if (request.response_format) { %>\n  response_format=<%- py_repr(request.response_format) %>,<% } %>\n<% if (request.seed !== undefined && request.seed !== null) { %>\n  seed=<%- py_repr(request.seed) %>,<% } %><% if (request.stop !== undefined && request.stop !== null) { %>\n  stop=<%- py_repr(request.stop) %>,<% } %>\n  <%- extra_body_py ? 'extra_body=' + extra_body_py + ',' : '' %>\n  stream=<%- request.stream?.toString()[0].toUpperCase() + request.stream?.toString().slice(1) %>,\n  tools=<%- py_repr(request.tools) %>,\n  <% if (request.tool_choice) { %>tool_choice=<%- py_repr(request.tool_choice) %><% } %>\n)<% } else { %>\ncompletion = client.chat.completions.create(\n  model=\"<%- request.model %>\",\n  messages=<%- py_repr(request.messages) %>,\n  temperature=<%- request.temperature %>,\n  top_p=<%- request.top_p %>,\n  max_tokens=<%- request.max_tokens %>,\n<% if (request.parallel_tool_calls !== undefined) { %>\n  parallel_tool_calls=<%- py_repr(request.parallel_tool_calls) %>,<% } %>\n<% if (request.stream_options) { %>\n  stream_options=<%- py_repr(request.stream_options) %>,<% } %>\n<% if (request.response_format) { %>\n  response_format=<%- py_repr(request.response_format) %>,<% } %>\n<% if (request.seed !== undefined && request.seed !== null) { %>\n  seed=<%- py_repr(request.seed) %>,<% } %><% if (request.stop !== undefined && request.stop !== null) { %>\n  stop=<%- py_repr(request.stop) %>,<% } %>\n  <%- extra_body_py ? 'extra_body=' + extra_body_py + ',' : '' %>\n  stream=<%- request.stream?.toString()[0].toUpperCase() + request.stream?.toString().slice(1) %>\n)<% } %>\n<% if (request.stream) { %>\nfor chunk in completion:\n  if not chunk.choices:\n    continue\n<% if (reasoning_enabled) { -%>\n  reasoning = getattr(chunk.choices[0].delta, \"reasoning_content\", None)\n  if reasoning:\n    print(reasoning, end=\"\")\n<% } -%>\n  if chunk.choices[0].delta.content is not None:\n    print(chunk.choices[0].delta.content, end=\"\")\n  <% if (request.tools) { %>if chunk.choices[0].delta.tool_calls:\n    print(chunk.choices[0].delta.tool_calls)<% } %>\n<% } else { %>\n<% if (reasoning_enabled) { -%>\nreasoning = getattr(completion.choices[0].message, \"reasoning_content\", None)\nif reasoning:\n  print(reasoning)\n<% } -%>\nprint(completion.choices[0].message.content or \"\")\n<% if (request.tools) { %>if completion.choices[0].message.tool_calls:\n  print(completion.choices[0].message.tool_calls)<% } %>\n<% } %>\n",
                "langChain": "import os\nfrom langchain_nvidia_ai_endpoints import ChatNVIDIA\n\n<%\n\nconst py_repr = (value) => {\n  if (value === null || value === undefined) return \"None\";\n  if (typeof value === \"boolean\") return value ? \"True\" : \"False\";\n  if (typeof value === \"string\") return JSON.stringify(value);\n  if (Array.isArray(value)) return \"[\" + value.map(py_repr).join(\", \") + \"]\";\n  if (typeof value === \"object\") return \"{\" + Object.entries(value).map(([key, item]) => JSON.stringify(key) + \": \" + py_repr(item)).join(\", \") + \"}\";\n  return String(value);\n};\nconst lc_reasoning_effort = request.reasoning_effort || \"high\";\nconst lc_chat_template_kwargs = request.chat_template_kwargs\n  ? request.chat_template_kwargs\n  : (lc_reasoning_effort === \"none\"\n      ? {\"enable_thinking\": false}\n      : (lc_reasoning_effort === \"low\"\n          ? {\"enable_thinking\": true, \"low_effort\": true}\n          : {\"enable_thinking\": true}));\nconst lc_reasoning_enabled = !!(lc_chat_template_kwargs && lc_chat_template_kwargs.enable_thinking);\nconst lc_chat_template_kwargs_py = lc_chat_template_kwargs\n  ? JSON.stringify(lc_chat_template_kwargs)\n      .replaceAll(\"true\", \"True\")\n      .replaceAll(\"false\", \"False\")\n      .replaceAll(\"null\", \"None\")\n  : null;\n%>\nclient = ChatNVIDIA(\n  base_url=\"https://integrate.api.nvidia.com/v1\",\n  model=\"<%- request.model %>\",\n  api_key=os.environ[\"NVIDIA_API_KEY\"],\n  temperature=<%- request.temperature %>,\n  top_p=<%- request.top_p %>,\n  max_completion_tokens=<%- request.max_tokens %>,\n<% if (request.stream_options) { %>\n  stream_options=<%- py_repr(request.stream_options) %>,<% } %>\n<% if (request.seed !== undefined && request.seed !== null) { %>\n  seed=<%- py_repr(request.seed) %>,<% } %><% if (request.stop !== undefined && request.stop !== null) { %>\n  stop=<%- py_repr(request.stop) %>,<% } %>\n)\n\n<%\nconst lc_kwargs = {chat_template_kwargs: lc_chat_template_kwargs};\nfor (const key of [\"tools\", \"tool_choice\", \"parallel_tool_calls\", \"response_format\"]) {\n  if (request[key] !== undefined && request[key] !== null) lc_kwargs[key] = request[key];\n}\n%>\nclient = client.bind(**<%- py_repr(lc_kwargs) %>)\n\n<% if (request.stream) { %>\nfor chunk in client.stream(<%- py_repr(request.messages) %>):\n  <% if (lc_reasoning_enabled) { %>\n    if chunk.additional_kwargs and \"reasoning_content\" in chunk.additional_kwargs:\n      print(chunk.additional_kwargs[\"reasoning_content\"], end=\"\")\n  <% } %>\n    print(chunk.content, end=\"\")\n    <% if (request.tools) { %>if chunk.tool_call_chunks:\n      print(chunk.tool_call_chunks)<% } %>\n<% } else { %>\nresponse = client.invoke(<%- py_repr(request.messages) %>)\n<% if (lc_reasoning_enabled) { -%>\nif response.additional_kwargs and \"reasoning_content\" in response.additional_kwargs:\n  print(response.additional_kwargs[\"reasoning_content\"])\n<% } -%>\nprint(response.content)\n<% if (request.tools) { %>if response.tool_calls:\n  print(response.tool_calls)<% } %>\n<% } %>\n",
                "node.js": "import OpenAI from 'openai';\n\nconst openai = new OpenAI({\n  apiKey: process.env.NVIDIA_API_KEY,\n  baseURL: 'https://integrate.api.nvidia.com/v1',\n})\n<%\nconst node_reasoning_effort = request.reasoning_effort || \"high\";\nconst node_chat_template_kwargs = request.chat_template_kwargs\n  ? request.chat_template_kwargs\n  : (node_reasoning_effort === \"none\"\n      ? {\"enable_thinking\": false}\n      : (node_reasoning_effort === \"low\"\n          ? {\"enable_thinking\": true, \"low_effort\": true}\n          : {\"enable_thinking\": true}));\nconst node_reasoning_enabled = !!(node_chat_template_kwargs && node_chat_template_kwargs.enable_thinking);\n%>\n <% if (request.tools) { %>\nasync function main() {\n  const completion = await openai.chat.completions.create({\n    model: \"<%- request.model %>\",\n    messages: <%- JSON.stringify(request.messages) %>,\n    temperature: <%- request.temperature %>,\n    top_p: <%- request.top_p %>,\n    max_tokens: <%- request.max_tokens %>,\n<% if (request.parallel_tool_calls !== undefined) { %>\n    parallel_tool_calls: <%- JSON.stringify(request.parallel_tool_calls) %>,<% } %>\n<% if (request.seed !== undefined && request.seed !== null) { %>\n    seed: <%- JSON.stringify(request.seed) %>,<% } %><% if (request.stop !== undefined && request.stop !== null) { %>\n    stop: <%- JSON.stringify(request.stop) %>,<% } %><% if (request.response_format !== undefined && request.response_format !== null) { %>\n    response_format: <%- JSON.stringify(request.response_format) %>,<% } %><% if (request.stream_options !== undefined && request.stream_options !== null) { %>\n    stream_options: <%- JSON.stringify(request.stream_options) %>,<% } %>\n    <%- node_chat_template_kwargs ? 'chat_template_kwargs: ' + JSON.stringify(node_chat_template_kwargs) + ',' : '' %>\n    stream: <%- request.stream %>,\n    <% if (request.tools) { %>tools: <%- JSON.stringify(request.tools) %>,<% } %>\n    <% if (request.tool_choice) { %>tool_choice: <%- JSON.stringify(request.tool_choice) %>,<% } %>\n  })<% } else { %>\nasync function main() {\n  const completion = await openai.chat.completions.create({\n    model: \"<%- request.model %>\",\n    messages: <%- JSON.stringify(request.messages) %>,\n    temperature: <%- request.temperature %>,\n    top_p: <%- request.top_p %>,\n    max_tokens: <%- request.max_tokens %>,\n<% if (request.parallel_tool_calls !== undefined) { %>\n    parallel_tool_calls: <%- JSON.stringify(request.parallel_tool_calls) %>,<% } %>\n<% if (request.seed !== undefined && request.seed !== null) { %>\n    seed: <%- JSON.stringify(request.seed) %>,<% } %><% if (request.stop !== undefined && request.stop !== null) { %>\n    stop: <%- JSON.stringify(request.stop) %>,<% } %><% if (request.response_format !== undefined && request.response_format !== null) { %>\n    response_format: <%- JSON.stringify(request.response_format) %>,<% } %><% if (request.stream_options !== undefined && request.stream_options !== null) { %>\n    stream_options: <%- JSON.stringify(request.stream_options) %>,<% } %>\n    <%- node_chat_template_kwargs ? 'chat_template_kwargs: ' + JSON.stringify(node_chat_template_kwargs) + ',' : '' %>\n    stream: <%- request.stream %>\n  })<% } %>\n   <% if (request.stream) { %>\n  for await (const chunk of completion) {\n    <% if (node_reasoning_enabled) { -%>\n    const reasoning = chunk.choices[0]?.delta?.reasoning_content;\n    if (reasoning) process.stdout.write(reasoning);\n    <% } -%>\n    process.stdout.write(chunk.choices[0]?.delta?.content || '')\n    <% if (request.tools) { %>if (chunk.choices[0]?.delta?.tool_calls) console.log(chunk.choices[0]?.delta?.tool_calls)<% } %>\n  }\n  <% } else { %>\n  <% if (node_reasoning_enabled) { -%>\n  const reasoning = completion.choices[0]?.message?.reasoning_content;\n  if (reasoning) process.stdout.write(reasoning + \"\\n\");\n  <% } -%>\n  process.stdout.write(completion.choices[0]?.message?.content || '');\n  <% if (request.tools) { %>if (completion.choices[0]?.message?.tool_calls) console.log(completion.choices[0]?.message?.tool_calls);<% } %>\n  <% } %>\n}\n\nmain();",
                "curl": "<%\nconst curl_reasoning_effort = request.reasoning_effort || \"high\";\nconst curl_chat_template_kwargs = request.chat_template_kwargs\n  ? request.chat_template_kwargs\n  : (curl_reasoning_effort === \"none\"\n      ? {\"enable_thinking\": false}\n      : (curl_reasoning_effort === \"low\"\n          ? {\"enable_thinking\": true, \"low_effort\": true}\n          : {\"enable_thinking\": true}));\n%>\ninvoke_url='https://integrate.api.nvidia.com/v1/chat/completions'\n\npayload=$(cat <<'JSON'\n{\n  \"model\": \"<%- request.model %>\",\n  \"messages\": <%- JSON.stringify(request.messages) %>,\n  \"temperature\": <%- request.temperature %>,\n  \"top_p\": <%- request.top_p %>,\n  \"max_tokens\": <%- request.max_tokens %>,\n<% if (request.parallel_tool_calls !== undefined) { %>\n  \"parallel_tool_calls\": <%- JSON.stringify(request.parallel_tool_calls) %>,<% } %>\n<% if (request.seed !== undefined && request.seed !== null) { %>\n  \"seed\": <%- JSON.stringify(request.seed) %>,<% } %><% if (request.stop !== undefined && request.stop !== null) { %>\n  \"stop\": <%- JSON.stringify(request.stop) %>,<% } %><% if (request.response_format !== undefined && request.response_format !== null) { %>\n  \"response_format\": <%- JSON.stringify(request.response_format) %>,<% } %><% if (request.stream_options !== undefined && request.stream_options !== null) { %>\n  \"stream_options\": <%- JSON.stringify(request.stream_options) %>,<% } %>\n  \"chat_template_kwargs\": <%- JSON.stringify(curl_chat_template_kwargs) %>,\n  \"stream\": <%- request.stream %><% if (request.tools) { %>,\n  \"tools\": <%- JSON.stringify(request.tools) %><% } %><% if (request.tool_choice) { %>,\n  \"tool_choice\": <%- JSON.stringify(request.tool_choice) %><% } %>\n}\nJSON\n)\n\nprintf 'header = \"Authorization: Bearer %s\"\\n' \"$NVIDIA_API_KEY\" | \\\ncurl --fail-with-body --config - -sS<%- request.stream ? ' -N' : '' %> \\\n  --request POST \\\n  --url \"$invoke_url\" \\\n  --header \"Accept: application/json\" \\\n  --header \"Content-Type: application/json\" \\\n  --data \"$payload\""
              },
              "response": "{\n  \"id\": \"chatcmpl-123\",\n  \"object\": \"chat.completion\",\n  \"created\": 1677652288,\n  \"model\": \"nvidia/nemotron-3.5-super-vl-120b-a12b\",\n  \"system_fingerprint\": \"fp_44709d6fcb\",\n  \"choices\": [{\n    \"index\": 0,\n    \"message\": {\n      \"role\": \"assistant\",\n      \"content\": \"\\n\\nHello there, how may I assist you today?\",\n    },\n    \"finish_reason\": \"stop\"\n  }],\n  \"usage\": {\n    \"prompt_tokens\": 9,\n    \"completion_tokens\": 12,\n    \"total_tokens\": 21\n  }\n}\n"
            }
          ]
        }
      }
    }
  },
  "security": [
    {
      "Token": []
    }
  ],
  "components": {
    "securitySchemes": {
      "Token": {
        "type": "http",
        "scheme": "bearer"
      }
    },
    "schemas": {
      "Errors": {
        "properties": {
          "type": {
            "type": "string",
            "description": "Error type"
          },
          "title": {
            "type": "string",
            "description": "Error title"
          },
          "status": {
            "type": "integer",
            "description": "Error status code"
          },
          "detail": {
            "type": "string",
            "description": "Detailed information about the error"
          },
          "instance": {
            "type": "string",
            "description": "Function instance used to invoke the request"
          },
          "requestId": {
            "type": "string",
            "format": "uuid",
            "description": "UUID of the request"
          }
        },
        "type": "object",
        "required": [
          "type",
          "title",
          "status",
          "detail",
          "instance",
          "requestId"
        ],
        "title": "InvokeError"
      },
      "ChatCompletion": {
        "properties": {
          "id": {
            "description": "A unique identifier for the completion.",
            "title": "Id",
            "type": "string"
          },
          "choices": {
            "description": "The list of completion choices the model generated for the input prompt.",
            "items": {
              "$ref": "#/components/schemas/Choice"
            },
            "title": "Choices",
            "type": "array"
          },
          "usage": {
            "allOf": [
              {
                "$ref": "#/components/schemas/Usage"
              }
            ],
            "description": "Usage statistics for the completion request."
          },
          "object": {
            "type": "string"
          },
          "created": {
            "type": "integer"
          },
          "model": {
            "type": "string",
            "description": "The serving function's primary registered model name; this may differ from a requested alias."
          }
        },
        "required": [
          "id",
          "choices",
          "usage"
        ],
        "title": "ChatCompletion",
        "type": "object"
      },
      "ChatCompletionChunk": {
        "properties": {
          "id": {
            "description": "A unique identifier for the completion.",
            "title": "Id",
            "type": "string"
          },
          "choices": {
            "description": "The list of completion choices the model generated for the input prompt.",
            "items": {
              "$ref": "#/components/schemas/ChoiceChunk"
            },
            "title": "Choices",
            "type": "array"
          },
          "object": {
            "type": "string"
          },
          "created": {
            "type": "integer"
          },
          "model": {
            "type": "string",
            "description": "The serving function's primary registered model name; this may differ from a requested alias."
          },
          "usage": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Usage"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "id",
          "choices"
        ],
        "title": "ChatCompletionChunk",
        "type": "object"
      },
      "ChatRequest": {
        "additionalProperties": false,
        "properties": {
          "model": {
            "type": "string",
            "title": "Model",
            "default": "nvidia/nemotron-3.5-super-vl-120b-a12b"
          },
          "messages": {
            "description": "Conversation messages. System and developer instructions, user messages, assistant responses, and tool results are supported. Include tool_call_id on tool results.",
            "examples": [
              [
                {
                  "content": "I am going to Paris, what should I see?",
                  "role": "user"
                }
              ]
            ],
            "items": {
              "$ref": "#/components/schemas/Message"
            },
            "title": "Messages",
            "type": "array",
            "minItems": 1
          },
          "temperature": {
            "default": 1,
            "description": "The sampling temperature to use for text generation. The higher the temperature value is, the less deterministic the output text will be. It is not recommended to modify both temperature and top_p in the same call.",
            "maximum": 2,
            "title": "Temperature",
            "type": "number",
            "minimum": 0
          },
          "top_p": {
            "default": 0.95,
            "description": "The top-p sampling mass used for text generation. The top-p value determines the probability mass that is sampled at sampling time. For example, if top_p = 0.2, only the most likely tokens (summing to 0.2 cumulative probability) will be sampled. It is not recommended to modify both temperature and top_p in the same call.",
            "maximum": 1,
            "exclusiveMinimum": 0,
            "title": "Top P",
            "type": "number"
          },
          "max_tokens": {
            "default": 16384,
            "description": "The maximum number of tokens to generate in any given call. Note that the model is not aware of this value, and generation will simply stop at the number of tokens specified. The hosted function caps completion budgets at 131072 tokens.",
            "maximum": 131072,
            "minimum": 1,
            "title": "Max Tokens",
            "type": "integer"
          },
          "reasoning_effort": {
            "enum": [
              "none",
              "low",
              "high"
            ],
            "default": "high",
            "title": "Reasoning Effort",
            "description": "Controls Super's reasoning mode. `none` disables reasoning tokens, `low` enables low-effort reasoning, and `high` enables full reasoning. Snippets translate this field into the model's `chat_template_kwargs`.",
            "type": "string"
          },
          "seed": {
            "anyOf": [
              {
                "maximum": 18446744073709552000,
                "minimum": 0,
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "default": 42,
            "description": "If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result.",
            "examples": [
              42
            ],
            "title": "Seed"
          },
          "stream": {
            "default": true,
            "description": "If set, partial message deltas will be sent. Tokens will be sent as data-only server-sent events (SSE) as they become available (JSON responses are prefixed by `data: `), with the stream terminated by a `data: [DONE]` message.",
            "title": "Stream",
            "type": "boolean"
          },
          "stop": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stop",
            "description": "A string or a list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence."
          },
          "tools": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/FunctionTool"
            },
            "description": "Function definitions available for tool calling."
          },
          "tool_choice": {
            "anyOf": [
              {
                "type": "string",
                "enum": [
                  "auto",
                  "none",
                  "required"
                ]
              },
              {
                "type": "object",
                "properties": {
                  "type": {
                    "const": "function"
                  },
                  "function": {
                    "type": "object",
                    "properties": {
                      "name": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ]
                  }
                },
                "required": [
                  "type",
                  "function"
                ]
              }
            ],
            "description": "Automatically select a tool, disable tools, require a tool, or select a named function."
          },
          "parallel_tool_calls": {
            "type": "boolean",
            "default": true,
            "description": "Whether multiple tool calls may be generated in one response."
          },
          "response_format": {
            "type": "object",
            "properties": {
              "type": {
                "type": "string",
                "enum": [
                  "text",
                  "json_object",
                  "json_schema"
                ]
              },
              "json_schema": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "strict": {
                    "type": "boolean"
                  },
                  "schema": {
                    "type": "object"
                  }
                },
                "required": [
                  "name",
                  "schema"
                ]
              }
            },
            "required": [
              "type"
            ],
            "description": "Use json_schema with a JSON schema to constrain structured output."
          },
          "stream_options": {
            "type": "object",
            "properties": {
              "include_usage": {
                "type": "boolean"
              },
              "continuous_usage_stats": {
                "type": "boolean"
              }
            },
            "description": "Include token usage in streamed chunks or emit continuous usage updates."
          },
          "chat_template_kwargs": {
            "type": "object",
            "additionalProperties": true,
            "description": "Optional chat-template arguments. Prefer reasoning_effort for the none, low, and high reasoning modes."
          }
        },
        "required": [
          "messages"
        ],
        "title": "ChatRequest",
        "type": "object"
      },
      "Choice": {
        "properties": {
          "index": {
            "description": "The index of the choice in the list of choices (always 0).",
            "title": "Index",
            "type": "integer"
          },
          "message": {
            "allOf": [
              {
                "$ref": "#/components/schemas/Message"
              }
            ],
            "description": "A chat completion message generated by the model.",
            "examples": [
              {
                "content": "Ah, Paris, the City of Light! There are so many amazing things to see and do in this beautiful city ...",
                "role": "assistant"
              }
            ]
          },
          "finish_reason": {
            "anyOf": [
              {
                "enum": [
                  "stop",
                  "length",
                  "tool_calls"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence, or `length` if the maximum number of tokens specified in the request was reached.",
            "examples": [
              "stop"
            ],
            "title": "Finish Reason"
          }
        },
        "required": [
          "index",
          "message"
        ],
        "title": "Choice",
        "type": "object"
      },
      "ChoiceChunk": {
        "properties": {
          "index": {
            "description": "The index of the choice in the list of choices (always 0).",
            "title": "Index",
            "type": "integer"
          },
          "delta": {
            "$ref": "#/components/schemas/MessageDelta",
            "description": "Partial assistant content, reasoning, or tool-call updates. Fields may be absent in a chunk."
          },
          "finish_reason": {
            "anyOf": [
              {
                "enum": [
                  "stop",
                  "length",
                  "tool_calls"
                ],
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "default": null,
            "description": "The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence, or `length` if the maximum number of tokens specified in the request was reached. Will be `null` if the model has not finished generating.",
            "title": "Finish Reason"
          }
        },
        "required": [
          "index",
          "delta"
        ],
        "title": "ChoiceChunk",
        "type": "object"
      },
      "Message": {
        "additionalProperties": false,
        "properties": {
          "role": {
            "description": "The role of the message author.",
            "enum": [
              "developer",
              "system",
              "user",
              "assistant",
              "tool",
              "function"
            ],
            "title": "Role",
            "type": "string"
          },
          "content": {
            "title": "Content",
            "description": "Text, multimodal content parts, or null for an assistant tool call.",
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/ContentPart"
                }
              },
              {
                "type": "null"
              }
            ]
          },
          "name": {
            "type": "string"
          },
          "tool_call_id": {
            "type": "string"
          },
          "tool_calls": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ToolCall"
            }
          },
          "reasoning_content": {
            "type": [
              "string",
              "null"
            ],
            "description": "Reasoning text returned separately from the final answer."
          },
          "function_call": {
            "type": [
              "object",
              "null"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "arguments": {
                "type": "string"
              }
            },
            "description": "Legacy assistant function call. Prefer tool_calls for new integrations."
          }
        },
        "required": [
          "role"
        ],
        "title": "Message",
        "type": "object"
      },
      "Usage": {
        "properties": {
          "completion_tokens": {
            "description": "Number of tokens in the generated completion.",
            "examples": [
              25
            ],
            "title": "Completion Tokens",
            "type": "integer"
          },
          "prompt_tokens": {
            "description": "Number of tokens in the prompt.",
            "examples": [
              9
            ],
            "title": "Prompt Tokens",
            "type": "integer"
          },
          "total_tokens": {
            "description": "Total number of tokens used in the request (prompt + completion).",
            "examples": [
              34
            ],
            "title": "Total Tokens",
            "type": "integer"
          },
          "prompt_tokens_details": {
            "type": [
              "object",
              "null"
            ],
            "properties": {
              "cached_tokens": {
                "type": "integer"
              }
            }
          },
          "completion_tokens_details": {
            "type": [
              "object",
              "null"
            ],
            "properties": {
              "reasoning_tokens": {
                "type": "integer"
              }
            }
          }
        },
        "required": [
          "completion_tokens",
          "prompt_tokens",
          "total_tokens"
        ],
        "title": "Usage",
        "type": "object"
      },
      "ContentPart": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "text",
              "image_url",
              "video_url"
            ]
          },
          "text": {
            "type": "string"
          },
          "image_url": {
            "type": "object",
            "properties": {
              "url": {
                "type": "string"
              },
              "detail": {
                "type": "string",
                "enum": [
                  "auto",
                  "low",
                  "high"
                ]
              }
            },
            "required": [
              "url"
            ]
          },
          "video_url": {
            "type": "object",
            "description": "Video input URL or data URI. MP4 and MOV with H.264 are supported.",
            "properties": {
              "url": {
                "type": "string"
              }
            },
            "required": [
              "url"
            ]
          }
        },
        "required": [
          "type"
        ]
      },
      "FunctionTool": {
        "type": "object",
        "properties": {
          "type": {
            "const": "function"
          },
          "function": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "parameters": {
                "type": "object"
              },
              "strict": {
                "type": "boolean"
              }
            },
            "required": [
              "name"
            ]
          }
        },
        "required": [
          "type",
          "function"
        ]
      },
      "ToolCall": {
        "type": "object",
        "properties": {
          "index": {
            "type": "integer"
          },
          "id": {
            "type": "string"
          },
          "type": {
            "const": "function"
          },
          "function": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string"
              },
              "arguments": {
                "type": "string",
                "description": "JSON-encoded function arguments."
              }
            }
          }
        }
      },
      "ValidationError": {
        "type": "object",
        "properties": {
          "message": {
            "type": "string"
          },
          "type": {
            "type": "string"
          },
          "code": {
            "type": "integer"
          }
        },
        "required": [
          "message",
          "type",
          "code"
        ]
      },
      "MessageDelta": {
        "additionalProperties": false,
        "properties": {
          "role": {
            "description": "The role of the message author.",
            "enum": [
              "developer",
              "system",
              "user",
              "assistant",
              "tool",
              "function"
            ],
            "title": "Role",
            "type": "string"
          },
          "content": {
            "title": "Content",
            "description": "Text, multimodal content parts, or null for an assistant tool call.",
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/ContentPart"
                }
              },
              {
                "type": "null"
              }
            ]
          },
          "name": {
            "type": "string"
          },
          "tool_call_id": {
            "type": "string"
          },
          "tool_calls": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/ToolCall"
            }
          },
          "reasoning_content": {
            "type": [
              "string",
              "null"
            ],
            "description": "Reasoning text returned separately from the final answer."
          },
          "function_call": {
            "type": [
              "object",
              "null"
            ],
            "properties": {
              "name": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "arguments": {
                "type": [
                  "string",
                  "null"
                ]
              }
            }
          }
        },
        "title": "MessageDelta",
        "type": "object"
      }
    }
  }
}
```