Image

API Reference

Last updated: 05-27-2026

API docs by Redocly

Nutanix Enterprise AI (2.7.0)

Download OpenAPI specification:

License: EULA

Introduction

Management APIs

The Nutanix Enterprise AI (NAI) Management API reference describes the RESTful APIs available to manage entities on the NAI platform. These APIs are currently in the experimental stage.

The API documentation is publicly accessible to all valid users without requiring special permissions, and is intended for viewing purposes only. This document covers the Inference and Management APIs available in the Nutanix Enterprise AI 2.7 release.

Inference APIs

The Nutanix Enterprise AI (NAI) Inference API reference describes the RESTful and streaming APIs you can use to interact with the Inference Endpoints deployed on the NAI platform. The REST API is currently in version 1 (v1). The rerank API is supported in version 2 (v2) to allow compatibility with Unified Endpoints.

Standard Base Path : enterpriseai/v1/

The best practice for ensuring consistent behavior and output from a model is to use a pinned model version. Model behaviors tend to change between versions.

All API users should have valid API Key credentials to send API calls to the Inference Endpoint. The Inference APIs are compliant with OpenAI API specifications, where applicable. Nutanix has added new tags to support models from other model catalog providers. You can invoke these APIs using the OpenAI API clients.

For more information on OpenAI Spec, see https://github.com/openai/openai-openapi/

Inference API Base Path Change (NAI 2.7+)

Starting with NAI 2.7, OpenAI APIs served via the AI Gateway will use a new base path. Always verify the Access URL on your Endpoint Overview page.

New Path: enterpriseai/gateway/v1/

Excluding audio type APIs, the new base path applies to all Unified Endpoints, Inference Models and KV-Aware enabled endpoints.

AI Gateway Base Path Examples

  • Unified Endpoint serving an Embedding model : enterpriseai/gateway/v1/embeddings
  • Listing AI Gateway models : enterpriseai/gateway/v1/models
  • KV-Aware enabled endpoint with text-to-text capability : enterpriseai/gateway/v1/chat/completions

MCP Connector APIs

The MCP Connectors in Nutanix Enterprise AI (NAI) 2.7 support version specification 2025-06-18 and the APIs: tools/, prompts/, and resources/. For more info on the MCP Specification, refer to: https://modelcontextprotocol.io/specification/2025-06-18

version

Get version

Retrieve NAI version information.

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/version \
    --header 'Accept: application/json' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

credentials

Create third party credential

Create a new third party credential.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create credential request object

required
object (dto.CredentialData)
name
required
string
type
required
string (enum.CredentialType)
Enum: "hf" "ngc" "openai" "anthropic" "cohere" "aws" "azure" "mistral" "google-gemini" "nai" "mcp-server-auth" "mcp-image-registry" "gcp"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/credentials \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "data": {
        "anthropic": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "aws": {
            "accessKeyID": "string",
            "hostname": "string",
            "port": 65535,
            "region": "string",
            "secretAccessKey": "string"
        },
        "azure": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "cohere": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "gcp": {
            "hostname": "string",
            "port": 65535,
            "projectName": "string",
            "region": "string",
            "serviceAccountJson": {
                "property1": "string",
                "property2": "string"
            }
        },
        "googleGemini": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "hf": {
            "token": "string"
        },
        "mcpImageRegistry": {
            "password": "string",
            "registryUrl": "string",
            "username": "string"
        },
        "mcpServer": {
            "apiKey": "string"
        },
        "mistral": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "nai": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "ngc": {
            "apiKey": "string"
        },
        "openai": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        }
    },
    "name": "string",
    "type": "hf"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search third party credentials

Search and filter third party credentials.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/credentials/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete third party credential by ID

Delete a third party credential by its ID.

Authorizations:
BasicAuth
path Parameters
credential_id
required
string

credential id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/credentials/{credential_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get third party credential by ID

Retrieve a specific third party credential by its ID.

Authorizations:
BasicAuth
path Parameters
credential_id
required
string

credential id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/credentials/{credential_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update third party credential

Update an existing third party credential.

Authorizations:
BasicAuth
path Parameters
credential_id
required
string

credential id

Request Body schema: application/json
required

updated credential object

object (dto.CredentialData)
name
string

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/credentials/{credential_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "data": {
        "anthropic": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "aws": {
            "accessKeyID": "string",
            "hostname": "string",
            "port": 65535,
            "region": "string",
            "secretAccessKey": "string"
        },
        "azure": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "cohere": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "gcp": {
            "hostname": "string",
            "port": 65535,
            "projectName": "string",
            "region": "string",
            "serviceAccountJson": {
                "property1": "string",
                "property2": "string"
            }
        },
        "googleGemini": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "hf": {
            "token": "string"
        },
        "mcpImageRegistry": {
            "password": "string",
            "registryUrl": "string",
            "username": "string"
        },
        "mcpServer": {
            "apiKey": "string"
        },
        "mistral": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "nai": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        },
        "ngc": {
            "apiKey": "string"
        },
        "openai": {
            "apiKey": "string",
            "hostname": "string",
            "port": 65535
        }
    },
    "name": "string"
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

licenses

List licenses

List all licenses.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/licenses \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Add license.

Add a new license.

Authorizations:
BasicAuth
Request Body schema: application/json
required

add licenses object

Array of objects (dto.License)

Responses

Request samples 

curl --request PUT \
    --url https://www.nutanix.dev/api/enterpriseai/v1/licenses \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "licenses": [
        {
            "licenseClusterUuid": "string",
            "licenseKey": "string",
            "meterType": "VCPU"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

Validate license key

Validate license key.

Authorizations:
BasicAuth
Request Body schema: application/json
required

validate licenses object

Array of objects (dto.License)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/licenses/validate \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "licenses": [
        {
            "licenseClusterUuid": "string",
            "licenseKey": "string",
            "meterType": "VCPU"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

catalogs

Update catalogs

Update one or more catalog entries.

Authorizations:
BasicAuth
Request Body schema: application/json
required

List of catalog entries to update

Array
adminEnabled
boolean
catalogId
required
string

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/catalogs \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": null,
  • "msg": "string",
  • "status": "Success"
}

Get Model requirement

Get resource requirements for a model.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new catalog requirements object

acceleratorMemory
number >= 0
acceleratorProduct
string
engine
string (enum.BaseEngine)
Enum: "vllm" "nim" "custom-model-server"
modelName
required
string
platform
required
string (enum.Platform)
Enum: "nvidia-gpu-passthrough" "nvidia-vgpu" "nvidia-mig" "intel-amx-cpu" "cpu"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/catalogs/requirements \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "acceleratorMemory": null,
    "acceleratorProduct": "string",
    "engine": "vllm",
    "modelName": "string",
    "platform": "nvidia-gpu-passthrough"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search for models

Search and filter models.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/catalogs/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete model

Delete a catalog entry by its ID.

Authorizations:
BasicAuth
path Parameters
catalog_id
required
string

catalog id

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/catalogs/{catalog_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get Model by ID

Retrieve a specific model entry by its ID.

Authorizations:
BasicAuth
path Parameters
catalog_id
required
string

catalog id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/catalogs/{catalog_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

models

Create model instance

Create a new instance of a model.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create model request object

object (dto.ModelProvider)
name
required
string <= 32 characters
sourceFormat
required
string (enum.SourceModelFormat)
Enum: "hf" "nim"
object (dto.ModelStorageProvider)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/models \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "modelProvider": {
        "catalogId": "string",
        "customModelDetails": {
            "developer": "string",
            "modelCapabilities": [
                "string"
            ],
            "modelSizeInGB": 0
        }
    },
    "name": "string",
    "sourceFormat": "hf",
    "storageProvider": {
        "huggingFaceHub": {
            "repoId": "string",
            "repoVersion": "string"
        },
        "nfs": {
            "dataPath": "string",
            "serverIp": "string",
            "sharePath": "string"
        },
        "s3": {
            "accessKey": "string",
            "bucket": "string",
            "dataPath": "string",
            "endpoint": "string",
            "secretKey": "string"
        }
    }
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Get Capabilities of a model

Get capabilities.

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/models/capabilities \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search model instances

Search and filter model instances.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/models/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete a model instance

Delete a model instance by its ID.

Authorizations:
BasicAuth
path Parameters
model_id
required
string

model id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/models/{model_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get Model instance by ID

Retrieve a specific model by its ID.

Authorizations:
BasicAuth
path Parameters
model_id
required
string

model id

query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/models/{model_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

logs

Get logs

Retrieve logs from pod instances.

Authorizations:
BasicAuth
query Parameters
entityType
required
string

Entity type (endpoint only). Note: In response filenames, this will be lowercase.

entityId
required
string

Entity ID

instance
required
string

Instance name

tailLines
integer

Number of lines to tail from the end of the logs

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/logs \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

download logs

Download logs file from pod instances.

Authorizations:
BasicAuth
query Parameters
entityType
required
string

Entity type (endpoint, model, or data-source).

entityId
required
string

Entity ID

instance
string

Instance name (required for endpoint, optional for model and data-source)

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/logs/download \
    --header 'Accept: application/octet-stream' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

endpoints

Create

Create a new endpoint.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create endpoint request object

acceleratorCount
required
integer
acceleratorProduct
string
object (dto.InferenceEngineArgs)
apiKeys
Array of strings
cpu
required
integer
description
string
enableKVAwareRouting
boolean
engine
required
string (enum.BaseEngine)
Enum: "vllm" "nim" "custom-model-server"
object (dto.EngineImage)
engineSource
required
string (enum.EngineSource)
Enum: "nai" "community" "custom"
maxInstances
integer >= 1
memoryInGi
required
integer
minInstances
integer >= 1
modelId
required
string
name
required
string <= 20 characters
platform
required
string (enum.Platform)
Enum: "nvidia-gpu-passthrough" "nvidia-vgpu" "nvidia-mig" "intel-amx-cpu" "cpu"
purpose
string (enum.EndpointPurpose)
Enum: "real-time" "batch"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "acceleratorCount": 0,
    "acceleratorProduct": "string",
    "advancedConfig": {
        "tgiArgs": {
            "maxNumTokens": 0
        },
        "vllmArgs": {
            "customArgs": {
                "property1": "string",
                "property2": "string"
            },
            "customEnvVars": {
                "property1": "string",
                "property2": "string"
            },
            "maxNumTokens": 0,
            "speculativeConfig": {
                "method": null,
                "ngram": null
            }
        }
    },
    "apiKeys": [
        "string"
    ],
    "cpu": 0,
    "description": "string",
    "enableKVAwareRouting": true,
    "engine": "vllm",
    "engineImageOverride": {
        "name": "string",
        "tag": "string"
    },
    "engineSource": "nai",
    "maxInstances": 1,
    "memoryInGi": 0,
    "minInstances": 1,
    "modelId": "string",
    "name": "string",
    "platform": "nvidia-gpu-passthrough",
    "purpose": "real-time"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

List API keys

List API keys associated with an endpoint.

Authorizations:
BasicAuth
path Parameters
endpoint_id
required
string

endpoint id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/apikeys/{endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search endpoints

Search and filter endpoints.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update state of an endpoint

Update the state of an endpoint.

Authorizations:
BasicAuth
path Parameters
endpoint_id
required
string

endpoint id

Request Body schema: application/json
required

update state of existing endpoint object

state
required
string (enum.EndpointStateAction)
Enum: "hibernate" "activate"

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/state/{endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "state": "hibernate"
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

Validate endpoint name

Validate endpoint name availability.

Authorizations:
BasicAuth
query Parameters
endpoint_name
required
string

endpoint name

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/validate \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Delete an endpoint

Delete an endpoint by its ID.

Authorizations:
BasicAuth
path Parameters
endpoint_id
required
string

endpoint id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/{endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get endpoint by ID

Retrieve a specific endpoint by its ID.

Authorizations:
BasicAuth
path Parameters
endpoint_id
required
string

endpoint id

query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/{endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update endpoint

Update an existing endpoint.

Authorizations:
BasicAuth
path Parameters
endpoint_id
required
string

endpoint id

Request Body schema: application/json
required

update existing endpoint object

description
string
maxInstances
integer >= 1
minInstances
integer >= 1

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/{endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "description": "string",
    "maxInstances": 1,
    "minInstances": 1
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

List instances of an endpoint

List instances for a specific endpoint ID.

Authorizations:
BasicAuth
path Parameters
endpoint_id
required
string

endpoint id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/endpoints/{endpoint_id}/instances \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

apikeys

Create API Key

Create a new API key for authentication.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new apikey create request object

endpoints
Array of strings
name
required
string
unifiedEndpoints
Array of strings

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/apikeys \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "endpoints": [
        "string"
    ],
    "name": "string",
    "unifiedEndpoints": [
        "string"
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search API key

Search and filter API keys.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/apikeys/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete API Key

Delete an API key by its ID.

Authorizations:
BasicAuth
path Parameters
apikey_id
required
string

apikey id

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/apikeys/{apikey_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Update API Key

Update API key status and associated endpoint IDs.

Authorizations:
BasicAuth
path Parameters
apikey_id
required
string

apikey id

Request Body schema: application/json
required

apikey update request object

endpoints
Array of strings
status
string
unifiedEndpoints
Array of strings

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/apikeys/{apikey_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "endpoints": [
        "string"
    ],
    "status": "string",
    "unifiedEndpoints": [
        "string"
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

metrics

Checks health of metrics

Checks health of metrics deployment.

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/metrics/health \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Query Metrics

Get Metrics

Authorizations:
BasicAuth
Request Body schema: application/json
required

new metric query object

object (dto.ExtraMetricParams)
metricName
required
string (constants.MetricName)
Enum: "requestLatencyAverage" "requestLatencyPercentile99" "requestLatencyPercentile95" "requestLatencyPercentile50" "requestCount" "cpuUsage" "memoryUsage" "diskUsage" "gpuUtil" "gpuCount" "usedGpuCount" "gpuMemoryUsage" "endpointStatusCount" "infrastructureSummary" "infrastructureSummaryNode" "timeToFirstTokenAverage" "timeToFirstTokenPercentile99" "timeToFirstTokenPercentile95" "timeToFirstTokenPercentile50" "timePerOutputTokenAverage" "timePerOutputTokenPercentile99" "timePerOutputTokenPercentile95" "timePerOutputTokenPercentile50" "requestThroughput" "inputTokenCount" "outputTokenCount" "cachedTokenCount" "outputTokenThroughput" "numRequestsRunning" "numRequestsWaiting" "mcpConnectorRequestCount" "mcpConnectorRequestLatencyAverage" "mcpConnectorRequestLatencyPercentile99" "mcpConnectorRequestLatencyPercentile95" "mcpConnectorRequestLatencyPercentile50"
outputType
required
string (constants.MetricOutputType)
Enum: "timeseries" "table"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/metrics/query \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "extraMetricParams": {
        "downsamplingInterval": 0,
        "end": 0,
        "filters": {
            "property1": [
                "string"
            ],
            "property2": [
                "string"
            ]
        },
        "groupBy": [
            "endpointName"
        ],
        "limit": 0,
        "sortOrder": "ASC",
        "start": 0
    },
    "metricName": "requestLatencyAverage",
    "outputType": "timeseries"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

auditlogs

Search Audit Logs

Search and retrieve audit log entries.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/auditlogs \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

scans

Initiate scan

Initiate a security scan for an entity

Authorizations:
BasicAuth
Request Body schema: application/json
required

create security scan request

object (dto.EndpointScanParams)
entityId
required
string
entityType
required
string (enum.SecurityScanEntityType)
Enum: "model" "endpoint"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/scans \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "endpoint": {
        "apiKey": "string",
        "baseUrl": "string"
    },
    "entityId": "string",
    "entityType": "model"
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

List security scan summary

List summary of security scans for all models and endpoints

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/scans/summary \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Abort scan

Abort a security scan by ID

Authorizations:
BasicAuth
path Parameters
scan_id
required
string

security scan id

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/scans/{scan_id}/abort \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

cluster

Get cluster config

Retrieve cluster configuration settings.

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/cluster/config \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update cluster configuration

Update cluster configuration settings.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new cluster config update request object

object (dto.EULAAcceptRequest)
object (dto.HfURLImportEnableUpdateRequest)
object (dto.ManualUploadEnableUpdateRequest)
object (dto.ProxySettings)
object (dto.PulseUpdateRequest)
object (dto.RsyslogServerInfo)
object (dto.SecuritySettingsUpdateRequest)

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/cluster/config \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "eula": {
        "accepted": true,
        "company": "string",
        "name": "string"
    },
    "hfUrlImport": {
        "enabled": true
    },
    "manualUpload": {
        "enabled": true
    },
    "proxySettings": {
        "name": "string",
        "password": "string",
        "port": 1,
        "protocols": [
            "string"
        ],
        "proxyAddress": "string",
        "username": "string"
    },
    "pulse": {
        "accepted": true
    },
    "rsyslogServer": {
        "logConfigs": [
            {
                "logSeverity": 0,
                "logType": "audit"
            }
        ],
        "name": "string",
        "port": 1,
        "protocol": "string",
        "serverAddress": "string"
    },
    "securitySettings": {
        "clientId": "string",
        "clientSecret": "string",
        "hfSecurityGroupUuid": "string",
        "networkChannelUuid": "string",
        "tsgId": "string"
    }
}'

Response samples

Content type
application/json
{
  • "data": null,
  • "msg": "string"
}

Get cluster health

Retrieve cluster health status.

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/cluster/health \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Get cluster info

Retrieve Kubernetes cluster information.

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/cluster/info \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

data-sources

Create datasource

Create a new data source.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create data source request object

name
required
string <= 32 characters
purpose
required
string (enum.DataSourcePurpose)
Enum: "finetune" "batch-inference"
sizeInMB
integer
object (dto.DataSourceStorageProvider)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/data-sources \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "name": "string",
    "purpose": "finetune",
    "sizeInMB": 0,
    "storageProvider": {
        "huggingFaceHub": {
            "repoId": "string",
            "repoVersion": "string"
        },
        "nfs": {
            "dataPath": "string",
            "serverIp": "string",
            "sharePath": "string"
        }
    }
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search

Search and filter data sources.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/data-sources/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete data source.

Delete a data source by its ID.

Authorizations:
BasicAuth
path Parameters
data_source_id
required
string

data source id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/data-sources/{data_source_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get a specific data source by ID

Retrieve a specific data source by its ID.

Authorizations:
BasicAuth
path Parameters
data_source_id
required
string

data source ID

query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/data-sources/{data_source_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

finetune-jobs

Create fine-tuning job

Create a new fine-tuning job.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create finetune request object

baseModelID
required
string
dataSourceID
required
string
object (dto.FinetuneMethodConfig)
name
required
string <= 32 characters
object (dto.Resources)
seed
integer

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/finetune-jobs \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "baseModelID": "string",
    "dataSourceID": "string",
    "methodConfig": {
        "additionalParams": {
            "lora": {
                "alpha": 1,
                "rank": 1
            }
        },
        "hyperparameters": {
            "batchSize": 1,
            "epochs": 1,
            "gradientAccumulationSteps": 1,
            "learningRate": null
        },
        "type": "supervised-lora"
    },
    "name": "string",
    "resources": {
        "acceleratorCount": 0,
        "acceleratorProduct": "string",
        "cpu": 0,
        "memoryInGi": 0
    },
    "seed": 0
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search fine-tuning jobs

Search and filter fine-tuning jobs.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/finetune-jobs/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete fine-tuning job by ID

Delete a fine-tuning job by its ID.

Authorizations:
BasicAuth
path Parameters
finetune_job_id
required
string

finetune job id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/finetune-jobs/{finetune_job_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get fine-tuning job by ID

Retrieve a specific fine-tuning job by its ID.

Authorizations:
BasicAuth
path Parameters
finetune_job_id
required
string

finetune job ID

query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/finetune-jobs/{finetune_job_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

batches

List batches

List batches

Authorizations:
BasicAuth
query Parameters
after
string

Pagination parameters

limit
string

limit

offset
string

offset

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/batches \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Create batch

Create a new batch.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create batch request object

completion_window
string
endpoint
string (openai.BatchEndpoint)
Enum: "/v1/chat/completions" "/v1/completions" "/v1/embeddings"
input_file_id
string
object

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/batches \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "completion_window": "string",
    "endpoint": "/v1/chat/completions",
    "input_file_id": "string",
    "metadata": {
        "property1": {},
        "property2": {}
    }
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search batches

Search batches

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/batches/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete batch

Delete a batch by ID

Authorizations:
BasicAuth
path Parameters
batch_id
required
string

batch ID

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/batches/{batch_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get batch

Get a batch by ID

Authorizations:
BasicAuth
path Parameters
batch_id
required
string

batch ID

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/batches/{batch_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Cancel batch

Cancel a batch by ID

Authorizations:
BasicAuth
path Parameters
batch_id
required
string

batch ID

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/batches/{batch_id}/cancel \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

providers

Create Provider

Create a new provider.

Authorizations:
BasicAuth
Request Body schema: application/json
required

provider

credentialId
required
string
name
required
string <= 20 characters
type
required
string (enum.LLMProviderType)
Enum: "anthropic" "awsBedrock" "azureOpenai" "cohere" "gcpVertexAI" "googleGemini" "mistral" "nai" "openai"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/providers \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "credentialId": "string",
    "name": "string",
    "type": "anthropic"
}'

Response samples

Content type
application/json
{
  • "data": "string",
  • "msg": "string"
}

Get Requirements

Get requirements for a provider.

Authorizations:
BasicAuth
Request Body schema: application/json

provider requirements

ingressApiSpec
string (enum.AIGatewayAPISpec)
Enum: "cohereRerankV2APISpec" "openaiChatV1APISpec" "openaiEmbeddingsV1APISpec" "openaiImageGenerationsV1APISpec"
type
string (enum.LLMProviderType)
Enum: "anthropic" "awsBedrock" "azureOpenai" "cohere" "gcpVertexAI" "googleGemini" "mistral" "nai" "openai"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/providers/requirements \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "ingressApiSpec": "awsBedrockConverseV1APISpec",
    "type": "anthropic"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search Providers

Search and filter providers.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/providers/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete provider

Delete a provider by id.

Authorizations:
BasicAuth
path Parameters
provider_id
required
string

provider id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/providers/{provider_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get Provider by ID

Get a provider by id.

Authorizations:
BasicAuth
path Parameters
provider_id
required
string

provider id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/providers/{provider_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update Provider

Update an provider by id.

Authorizations:
BasicAuth
path Parameters
provider_id
required
string

provider id

Request Body schema: application/json
required

provider

credentialId
string

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/providers/{provider_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "credentialId": "string"
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

unified-endpoints

Create unified endpoint

Create a new unified endpoint.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create unified endpoint request object

apiKeys
Array of strings
apiSpec
required
string (enum.AIGatewayAPISpec)
Enum: "cohereRerankV2APISpec" "openaiChatV1APISpec" "openaiEmbeddingsV1APISpec" "openaiImageGenerationsV1APISpec"
mode
required
string (enum.UnifiedEndpointMode)
Enum: "loadbalancer" "fallback"
name
required
string <= 20 characters
required
Array of objects (dto.TargetEndpointConfig) <= 16 items

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "apiKeys": [
        "string"
    ],
    "apiSpec": "awsBedrockConverseV1APISpec",
    "mode": "loadbalancer",
    "name": "string",
    "targetEndpoints": [
        {
            "endpointType": "internal",
            "internalEndpointId": "string",
            "priority": 0,
            "providerId": "string",
            "providerModelName": "string",
            "weight": 0
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

List API keys

List API keys for a unified endpoint.

Authorizations:
BasicAuth
path Parameters
unified_endpoint_id
required
string

unified endpoint id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/apikeys/{unified_endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search unified endpoints.

Search and filter unified endpoints.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete unified endpoints

Delete a unified endpoint by its ID.

Authorizations:
BasicAuth
path Parameters
unified_endpoint_id
required
string

unified endpoint id

query Parameters
force
boolean

force delete

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/{unified_endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get unified endpoint by ID

Retrieve a specific unified endpoint by its ID.

Authorizations:
BasicAuth
path Parameters
unified_endpoint_id
required
string

unified endpoint id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/{unified_endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update unified endpoint

Update an existing unified endpoint.

Authorizations:
BasicAuth
path Parameters
unified_endpoint_id
required
string

unified endpoint id

Request Body schema: application/json
required

update unified endpoint request object

apiSpec
string (enum.AIGatewayAPISpec)
Enum: "cohereRerankV2APISpec" "openaiChatV1APISpec" "openaiEmbeddingsV1APISpec" "openaiImageGenerationsV1APISpec"
mode
string (enum.UnifiedEndpointMode)
Enum: "loadbalancer" "fallback"
Array of objects (dto.TargetEndpointConfig) <= 16 items

Responses

Request samples 

curl --request PUT \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/{unified_endpoint_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "apiSpec": "awsBedrockConverseV1APISpec",
    "mode": "loadbalancer",
    "targetEndpoints": [
        {
            "endpointType": "internal",
            "internalEndpointId": "string",
            "priority": 0,
            "providerId": "string",
            "providerModelName": "string",
            "weight": 0
        }
    ]
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

List rate limits

List rate limit configurations for an unified endpoint.

Authorizations:
BasicAuth
path Parameters
unified_endpoint_id
required
string

unified endpoint id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/{unified_endpoint_id}/ratelimit \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update rate limit

Update rate limit configuration on a unified endpoint.

Authorizations:
BasicAuth
path Parameters
unified_endpoint_id
required
string

unified endpoint id

Request Body schema: application/json
required

Rate limit configurations

Array of objects (dto.APIKeySpecificRateLimitConfig)

APIKeys specifies API key specific rate limit configurations.

  • When nil/not provided: preserves existing API key rate limit configurations
  • When empty slice: removes all existing API key rate limit configurations
  • When contains items: updates specific API key rate limit configurations
object

Global specifies the global rate limit configuration.

  • When nil/not provided: preserves existing global rate limit configuration
  • When provided but rateLimitConfig is null: removes existing global rate limit configuration
  • When provided with rateLimitConfig: updates global rate limit configuration

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/unified-endpoints/{unified_endpoint_id}/ratelimit \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "apiKeys": [
        {
            "apiKeyId": "string",
            "rateLimitConfig": {
                "cost": null,
                "durationUnit": null,
                "value": 0
            }
        }
    ],
    "global": null
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

mcp-servers

Create MCP Server

create a new MCP server

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create MCP server request object

object (dto.LocalMCPServer)
name
required
string <= 32 characters
object (dto.RemoteMCPServer)
serverAuthCredentialId
string
serverType
required
string (enum.MCPServerType)
Enum: "remote" "local"

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/servers/ \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "localMcpServer": {
        "args": [
            "string"
        ],
        "cpuMilliCores": 0,
        "env": {
            "property1": "string",
            "property2": "string"
        },
        "instances": 1,
        "memoryInMi": 0,
        "packageName": "string",
        "packageType": "docker",
        "port": 1,
        "registryCredentialId": "string"
    },
    "name": "string",
    "remoteMcpServer": {
        "url": "string"
    },
    "serverAuthCredentialId": "string",
    "serverType": "remote"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search MCP Server

Search MCP Servers.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/servers/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete MCP Server

Delete a MCP Server.

Authorizations:
BasicAuth
path Parameters
mcp_server_id
required
string

MCP Server id

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/servers/{mcp_server_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get MCP Server by ID

Retrieve a specific MCP server by its ID.

Authorizations:
BasicAuth
path Parameters
mcp_server_id
required
string

MCP server id

query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/servers/{mcp_server_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

List tools in an MCP Server.

List all available tools on an MCP server.

Authorizations:
BasicAuth
path Parameters
mcp_server_id
required
string

MCP server id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/servers/{mcp_server_id}/tools \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

mcp-connectors

Create MCP Connector

Create a new MCP connector.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new create MCP connector request object

mcpKeys
Array of strings
required
Array of objects (dto.MCPServerWithTools) non-empty
name
required
string <= 32 characters

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "mcpKeys": [
        "string"
    ],
    "mcpServers": [
        {
            "allowedTools": [
                "string"
            ],
            "serverId": "string"
        }
    ],
    "name": "string"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search MCP Connectors

Search and filter MCP connectors.

Authorizations:
BasicAuth
query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Validate MCP Connector

Validate an MCP connector name.

Authorizations:
BasicAuth
query Parameters
mcp_connector_name
required
string

MCP connector name

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/validate \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Delete MCP Connector

Delete an MCP connector by its ID.

Authorizations:
BasicAuth
path Parameters
mcp_connector_id
required
string

MCP connector id

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/{mcp_connector_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Get MCP connector by ID

Retrieve a specific MCP connector by its ID.

Authorizations:
BasicAuth
path Parameters
mcp_connector_id
required
string

MCP connector id

query Parameters
expand
Array of strings

query param to denote what all extra fields to fetch

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/{mcp_connector_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Update MCP connector

Update an existing MCP connector.

Authorizations:
BasicAuth
path Parameters
mcp_connector_id
required
string

MCP connector id

Request Body schema: application/json
required

update MCP connector request object

mcpKeys
Array of strings
Array of objects (dto.MCPServerWithTools)

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/{mcp_connector_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "mcpKeys": [
        "string"
    ],
    "mcpServers": [
        {
            "allowedTools": [
                "string"
            ],
            "serverId": "string"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

List MCP keys

List MCP keys for a specific connector.

Authorizations:
BasicAuth
path Parameters
mcp_connector_id
required
string

connector id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/{mcp_connector_id}/mcpkeys \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

List MCP servers

List MCP servers for a specific connector.

Authorizations:
BasicAuth
path Parameters
mcp_connector_id
required
string

connector id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/{mcp_connector_id}/mcpservers \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

List MCP Server Tools

List available and allowed tools for a server within a connector context.

Authorizations:
BasicAuth
path Parameters
mcp_connector_id
required
string

MCP connector id

mcp_server_id
required
string

MCP server id

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcp/connectors/{mcp_connector_id}/servers/{mcp_server_id}/tools \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

mcpkeys

Create an MCP key

Create a new MCP key.

Authorizations:
BasicAuth
Request Body schema: application/json
required

new MCP key create request object

connectors
Array of strings
name
required
string <= 32 characters

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcpkeys \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "connectors": [
        "string"
    ],
    "name": "string"
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Search MCP Key

Search and filter MCP keys.

Authorizations:
BasicAuth
Request Body schema: application/json
required

list options object

required
Array of objects (dto.FilterOptions)
limit
required
integer
offset
required
integer >= 0
required
Array of objects (dto.SortOptions)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcpkeys/search \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "filters": [
        {
            "field": "string",
            "operation": "startsWith",
            "values": [
                "string"
            ]
        }
    ],
    "limit": 0,
    "offset": 0,
    "sort": [
        {
            "field": "string",
            "order": "ASCENDING"
        }
    ]
}'

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

Delete

Delete MCP key with id.

Authorizations:
BasicAuth
path Parameters
mcpkey_id
required
string

mcpkey id

Responses

Request samples 

curl --request DELETE \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcpkeys/{mcpkey_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "msg": "string"
}

Update MCP Key

Update MCP key with status and connector id list.

Authorizations:
BasicAuth
path Parameters
mcpkey_id
required
string

mcpkey id

Request Body schema: application/json
required

mcpkey update request object

connectors
Array of strings
status
string

Responses

Request samples 

curl --request PATCH \
    --url https://www.nutanix.dev/api/enterpriseai/v1/mcpkeys/{mcpkey_id} \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \
    --header 'Content-Type: application/json' \
    --data '{
    "connectors": [
        "string"
    ],
    "status": "string"
}'

Response samples

Content type
application/json
{
  • "msg": "string"
}

users

Get current user

Retrieve current user information and system status.

Authorizations:
BasicAuth

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/api/enterpriseai/v1/users/me \
    --header 'Accept: application/json' \
    --header 'Authorization: Basic <basic_auth_token>' \

Response samples

Content type
application/json
{
  • "data": {
    },
  • "msg": "string"
}

inference-models

List models

Lists the currently available models and provides basic information, such as the owner and availability

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Responses

Request samples 

curl --request GET \
    --url https://www.nutanix.dev/enterpriseai/v1/models \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: application/json' \

Response samples

Content type
application/json
{
  • "data": [
    ],
  • "object": "string"
}

chat

Create chat completion

The chat completions API generates a model response from a list of messages comprising a conversation. This request creates a model response for the given chat conversation.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: application/json
required

Parameters required to create the chat completion request.

object

ChatTemplateKwargs provides a way to add non-standard parameters to the request body. Additional kwargs to pass to the template renderer. Will be accessible by the chat template. Such as think mode for qwen3. "chat_template_kwargs": {"enable_thinking": false} https://qwen.readthedocs.io/en/latest/deployment/vllm.html#thinking-non-thinking-modes

frequency_penalty
number
function_call
any

Deprecated: use ToolChoice instead.

Array of objects (openai.FunctionDefinition)

Deprecated: use Tools instead.

guided_choice
Array of strings

GuidedChoice is a vLLM-specific extension that restricts the model's output to one of the predefined string choices provided in this field. This feature is used to constrain the model's responses to a controlled set of options, ensuring predictable and consistent outputs in scenarios where specific choices are required.

ignore_eos
boolean
object

LogitBias is must be a token id string (specified by their token ID in the tokenizer), not a word string. incorrect: "logit_bias":{"You": 6}, correct: "logit_bias":{"1639": 6} refs: https://platform.openai.com/docs/api-reference/chat/create#chat/create-logit_bias

logprobs
boolean

LogProbs indicates whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message. This option is currently not available on the gpt-4-vision-preview model.

max_completion_tokens
integer

MaxCompletionTokens An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens https://platform.openai.com/docs/guides/reasoning

max_tokens
integer

MaxTokens The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API. Deprecated: use MaxCompletionTokens. Not compatible with o1-series models. refs: https://platform.openai.com/docs/api-reference/chat/create#chat-create-max_tokens

Array of objects (openai.ChatCompletionMessage)
object

Metadata to store with the completion.

min_tokens
integer
model
string
n
integer
parallel_tool_calls
any

Disable the default behavior of parallel tool calls by setting it: false.

object

Configuration for a predicted output.

presence_penalty
number
reasoning_effort
string

Controls effort on reasoning for reasoning models. It can be set to "low", "medium", or "high".

object (openai.ChatCompletionResponseFormat)
safety_identifier
string

A stable identifier used to help detect users of your application that may be violating OpenAI's usage policies. The IDs should be a string that uniquely identifies each user. We recommend hashing their username or email address, in order to avoid sending us any identifying information. https://platform.openai.com/docs/api-reference/chat/create#chat_create-safety_identifier

seed
integer
service_tier
string
Enum: "auto" "default" "flex" "priority"

Specifies the latency tier to use for processing the request.

stop
Array of strings
store
boolean

Store can be set to true to store the output of this completion request for use in distillations and evals. https://platform.openai.com/docs/api-reference/chat/create#chat-create-store

stream
boolean
object

Options for streaming response. Only set this when you set stream: true.

temperature
number
tool_choice
any

This can be either a string or an ToolChoice object.

Array of objects (openai.Tool)
top_logprobs
integer

TopLogProbs is an integer between 0 and 5 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.

top_p
number
user
string
verbosity
string

Verbosity determines how many output tokens are generated. Lowering the number of tokens reduces overall latency. It can be set to "low", "medium", or "high". Note: This field is only confirmed to work with gpt-5, gpt-5-mini and gpt-5-nano. Also, it is not in the API reference of chat completion at the time of writing, though it is supported by the API.

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v1/chat/completions \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: application/json' \
    --data '{
    "chat_template_kwargs": {
        "property1": {},
        "property2": {}
    },
    "frequency_penalty": null,
    "function_call": null,
    "functions": [
        {
            "description": "string",
            "name": "string",
            "parameters": null,
            "strict": true
        }
    ],
    "guided_choice": [
        "string"
    ],
    "ignore_eos": true,
    "logit_bias": {
        "property1": 0,
        "property2": 0
    },
    "logprobs": true,
    "max_completion_tokens": 0,
    "max_tokens": 0,
    "messages": [
        {
            "content": "string",
            "function_call": {
                "arguments": "string",
                "name": "string"
            },
            "multiContent": [
                {
                    "image_url": {
                        "detail": "high",
                        "url": "string"
                    },
                    "text": "string",
                    "type": "text"
                }
            ],
            "name": "string",
            "reasoning": "string",
            "reasoning_content": "string",
            "refusal": "string",
            "role": "string",
            "tool_call_id": "string",
            "tool_calls": [
                {
                    "function": {
                        "arguments": "string",
                        "name": "string"
                    },
                    "id": "string",
                    "index": 0,
                    "type": "function"
                }
            ]
        }
    ],
    "metadata": {
        "property1": "string",
        "property2": "string"
    },
    "min_tokens": 0,
    "model": "string",
    "n": 0,
    "parallel_tool_calls": null,
    "prediction": null,
    "presence_penalty": null,
    "reasoning_effort": "string",
    "response_format": {
        "json_schema": {
            "description": "string",
            "name": "string",
            "schema": null,
            "strict": true
        },
        "type": "json_object"
    },
    "safety_identifier": "string",
    "seed": 0,
    "service_tier": null,
    "stop": [
        "string"
    ],
    "store": true,
    "stream": true,
    "stream_options": null,
    "temperature": null,
    "tool_choice": null,
    "tools": [
        {
            "function": {
                "description": "string",
                "name": "string",
                "parameters": null,
                "strict": true
            },
            "type": "function"
        }
    ],
    "top_logprobs": 0,
    "top_p": null,
    "user": "string",
    "verbosity": "string"
}'

Response samples

Content type
application/json
{
  • "choices": [
    ],
  • "created": 0,
  • "id": "string",
  • "model": "string",
  • "object": "string",
  • "prompt_filter_results": [
    ],
  • "service_tier": "auto",
  • "system_fingerprint": "string",
  • "usage": {
    }
}

embeddings

Create embeddings

The embedding API generates a vector representation of a given input that can be easily consumed by machine learning models and algorithms. This request creates an embedding vector representing the input text.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: application/json
required

Parameters required to generate a request.

dimensions
integer

Dimensions. The number of dimensions the resulting output embeddings should have. Only supported in text-embedding-3 and later models.

encoding_format
string (openai.EmbeddingEncodingFormat)
Enum: "float" "base64"
object

The ExtraBody field allows for the inclusion of arbitrary key-value pairs in the request body that may not be explicitly defined in this struct.

input
any
input_type
string
model
string (openai.EmbeddingModel)
Enum: "text-similarity-ada-001" "text-similarity-babbage-001" "text-similarity-curie-001" "text-similarity-davinci-001" "text-search-ada-doc-001" "text-search-ada-query-001" "text-search-babbage-doc-001" "text-search-babbage-query-001" "text-search-curie-doc-001" "text-search-curie-query-001" "text-search-davinci-doc-001" "text-search-davinci-query-001" "code-search-ada-code-001" "code-search-ada-text-001" "code-search-babbage-code-001" "code-search-babbage-text-001" "text-embedding-ada-002" "text-embedding-3-small" "text-embedding-3-large"
truncate
string
user
string

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v1/embeddings \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: application/json' \
    --data '{
    "dimensions": 0,
    "encoding_format": "float",
    "extra_body": {
        "property1": {},
        "property2": {}
    },
    "input": null,
    "input_type": "string",
    "model": "text-similarity-ada-001",
    "truncate": "string",
    "user": "string"
}'

Response samples

Content type
application/json
{
  • "data": [
    ],
  • "model": "text-similarity-ada-001",
  • "object": "string",
  • "usage": {
    }
}

images

Generate images

The image generation API generates images from a text prompt.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: application/json
required

Parameters required to create the image generation request

background
string
cfg_scale
number
inference_steps
integer
model
string
moderation
string
n
integer
output_compression
integer
output_format
string
prompt
string
quality
string
response_format
string
seed
integer
size
string
style
string
user
string

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v1/images/generations \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: application/json' \
    --data '{
    "background": "string",
    "cfg_scale": null,
    "inference_steps": 0,
    "model": "string",
    "moderation": "string",
    "n": 0,
    "output_compression": 0,
    "output_format": "string",
    "prompt": "string",
    "quality": "string",
    "response_format": "string",
    "seed": 0,
    "size": "string",
    "style": "string",
    "user": "string"
}'

Response samples

Content type
application/json
{
  • "artifacts": [
    ],
  • "created": 0,
  • "data": [
    ],
  • "usage": {
    }
}

audio

Create transcription

The audio transcription API transcribes audio into text.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: multipart/form-data
required
file
required
string <binary>

The audio file to transcribe (flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm)

model
required
string

Name of the endpoint to use

prompt
string

Optional text to guide the model's style

response_format
string

The format of the transcript output (json, text, srt, verbose_json, or vtt)

temperature
number

The sampling temperature, between 0 and 1

language
string

The language of the input audio in ISO-639-1 format

timestamp_granularities[]
string

The timestamp granularities to populate (segment or word)

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v1/audio/transcriptions \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: multipart/form-data' \
    --data '{
    "file": null,
    "language": "string",
    "model": "string",
    "prompt": "string",
    "response_format": "string",
    "temperature": null,
    "timestamp_granularities[]": "string"
}'

Response samples

Content type
application/json
{
  • "duration": 0,
  • "language": "string",
  • "segments": [
    ],
  • "task": "string",
  • "text": "string",
  • "words": [
    ]
}

Create translation

The audio translation API translates audio into text.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: multipart/form-data
required
file
required
string <binary>

The audio file to translate (flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm)

model
required
string

Name of the endpoint to use

prompt
string

Optional text to guide the model's style

response_format
string

The format of the transcript output (json, text, srt, verbose_json, or vtt)

temperature
number

The sampling temperature, between 0 and 1

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v1/audio/translations \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: multipart/form-data' \
    --data '{
    "file": null,
    "model": "string",
    "prompt": "string",
    "response_format": "string",
    "temperature": null
}'

Response samples

Content type
application/json
{
  • "duration": 0,
  • "language": "string",
  • "segments": [
    ],
  • "task": "string",
  • "text": "string",
  • "words": [
    ]
}

rerank

Rerank documents

Rerank documents by relevance to query.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: application/json
required

Parameters required to create the rerank request

required
Array of objects (dto.Document)
model
required
string
query
required
string
return_documents
boolean
top_n
integer >= 0
truncate
boolean

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v1/rerank \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: application/json' \
    --data '{
    "documents": [
        {
            "text": "string"
        }
    ],
    "model": "string",
    "query": "string",
    "return_documents": true,
    "top_n": 0,
    "truncate": true
}'

Response samples

Content type
application/json
{
  • "meta": {
    },
  • "results": [
    ]
}

Rerank documents with v2

Rerank documents.

header Parameters
Authorization
required
string
Default: Bearer <Add access token here>

API key for authentication

Request Body schema: application/json
required

Parameters required to create the rerank request

documents
required
Array of strings

Documents to be compared with the query. For best performance, keep under 1000. Long documents may be truncated server-side by max_tokens_per_doc.

max_tokens_per_doc
integer >= 0

Optional: truncate long documents to this many tokens. Default: 4096.

model
required
string

Model identifier to use, e.g. "rerank-v3.5".

query
required
string

Query to rank documents against.

top_n
integer >= 0

Optional: limit returned results to top_n.

Responses

Request samples 

curl --request POST \
    --url https://www.nutanix.dev/enterpriseai/v2/rerank \
    --header 'Accept: application/json' \
    --header 'Authorization: Bearer <Add access token here>' \
    --header 'Content-Type: application/json' \
    --data '{
    "documents": [
        "string"
    ],
    "max_tokens_per_doc": 0,
    "model": "string",
    "query": "string",
    "top_n": 0
}'

Response samples

Content type
application/json
{
  • "id": "string",
  • "meta": {
    },
  • "results": [
    ]
}