Create a custom model

curl --request POST \
  --url https://api.egp.scale.com/v5/models \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "name": "<string>",
  "vendor_configuration": {
    "model_image": {
      "registry": "<string>",
      "repository": "<string>",
      "tag": "<string>",
      "command": [
        "<string>"
      ],
      "predict_route": "/predict",
      "streaming_predict_route": "<string>",
      "streaming_command": [
        "<string>"
      ],
      "request_schema": {},
      "response_schema": {},
      "env_vars": {},
      "readiness_delay": 120,
      "healthcheck_route": "/readyz"
    },
    "model_infra": {
      "endpoint_type": "sync",
      "cpus": 3,
      "gpus": 0,
      "memory": "8Gi",
      "storage": "16Gi",
      "min_workers": 0,
      "max_workers": 1,
      "per_worker": 10,
      "high_priority": false,
      "labels": {},
      "public_inference": false
    }
  },
  "model_type": "generic",
  "model_vendor": "launch",
  "model_metadata": {},
  "on_conflict": "error"
}
'

import requests

url = "https://api.egp.scale.com/v5/models"

payload = {
    "name": "<string>",
    "vendor_configuration": {
        "model_image": {
            "registry": "<string>",
            "repository": "<string>",
            "tag": "<string>",
            "command": ["<string>"],
            "predict_route": "/predict",
            "streaming_predict_route": "<string>",
            "streaming_command": ["<string>"],
            "request_schema": {},
            "response_schema": {},
            "env_vars": {},
            "readiness_delay": 120,
            "healthcheck_route": "/readyz"
        },
        "model_infra": {
            "endpoint_type": "sync",
            "cpus": 3,
            "gpus": 0,
            "memory": "8Gi",
            "storage": "16Gi",
            "min_workers": 0,
            "max_workers": 1,
            "per_worker": 10,
            "high_priority": False,
            "labels": {},
            "public_inference": False
        }
    },
    "model_type": "generic",
    "model_vendor": "launch",
    "model_metadata": {},
    "on_conflict": "error"
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    name: '<string>',
    vendor_configuration: {
      model_image: {
        registry: '<string>',
        repository: '<string>',
        tag: '<string>',
        command: ['<string>'],
        predict_route: '/predict',
        streaming_predict_route: '<string>',
        streaming_command: ['<string>'],
        request_schema: {},
        response_schema: {},
        env_vars: {},
        readiness_delay: 120,
        healthcheck_route: '/readyz'
      },
      model_infra: {
        endpoint_type: 'sync',
        cpus: 3,
        gpus: 0,
        memory: '8Gi',
        storage: '16Gi',
        min_workers: 0,
        max_workers: 1,
        per_worker: 10,
        high_priority: false,
        labels: {},
        public_inference: false
      }
    },
    model_type: 'generic',
    model_vendor: 'launch',
    model_metadata: {},
    on_conflict: 'error'
  })
};

fetch('https://api.egp.scale.com/v5/models', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.egp.scale.com/v5/models",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '<string>',
    'vendor_configuration' => [
        'model_image' => [
                'registry' => '<string>',
                'repository' => '<string>',
                'tag' => '<string>',
                'command' => [
                                '<string>'
                ],
                'predict_route' => '/predict',
                'streaming_predict_route' => '<string>',
                'streaming_command' => [
                                '<string>'
                ],
                'request_schema' => [
                                
                ],
                'response_schema' => [
                                
                ],
                'env_vars' => [
                                
                ],
                'readiness_delay' => 120,
                'healthcheck_route' => '/readyz'
        ],
        'model_infra' => [
                'endpoint_type' => 'sync',
                'cpus' => 3,
                'gpus' => 0,
                'memory' => '8Gi',
                'storage' => '16Gi',
                'min_workers' => 0,
                'max_workers' => 1,
                'per_worker' => 10,
                'high_priority' => false,
                'labels' => [
                                
                ],
                'public_inference' => false
        ]
    ],
    'model_type' => 'generic',
    'model_vendor' => 'launch',
    'model_metadata' => [
        
    ],
    'on_conflict' => 'error'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.egp.scale.com/v5/models"

	payload := strings.NewReader("{\n  \"name\": \"<string>\",\n  \"vendor_configuration\": {\n    \"model_image\": {\n      \"registry\": \"<string>\",\n      \"repository\": \"<string>\",\n      \"tag\": \"<string>\",\n      \"command\": [\n        \"<string>\"\n      ],\n      \"predict_route\": \"/predict\",\n      \"streaming_predict_route\": \"<string>\",\n      \"streaming_command\": [\n        \"<string>\"\n      ],\n      \"request_schema\": {},\n      \"response_schema\": {},\n      \"env_vars\": {},\n      \"readiness_delay\": 120,\n      \"healthcheck_route\": \"/readyz\"\n    },\n    \"model_infra\": {\n      \"endpoint_type\": \"sync\",\n      \"cpus\": 3,\n      \"gpus\": 0,\n      \"memory\": \"8Gi\",\n      \"storage\": \"16Gi\",\n      \"min_workers\": 0,\n      \"max_workers\": 1,\n      \"per_worker\": 10,\n      \"high_priority\": false,\n      \"labels\": {},\n      \"public_inference\": false\n    }\n  },\n  \"model_type\": \"generic\",\n  \"model_vendor\": \"launch\",\n  \"model_metadata\": {},\n  \"on_conflict\": \"error\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.egp.scale.com/v5/models")
  .header("x-api-key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"<string>\",\n  \"vendor_configuration\": {\n    \"model_image\": {\n      \"registry\": \"<string>\",\n      \"repository\": \"<string>\",\n      \"tag\": \"<string>\",\n      \"command\": [\n        \"<string>\"\n      ],\n      \"predict_route\": \"/predict\",\n      \"streaming_predict_route\": \"<string>\",\n      \"streaming_command\": [\n        \"<string>\"\n      ],\n      \"request_schema\": {},\n      \"response_schema\": {},\n      \"env_vars\": {},\n      \"readiness_delay\": 120,\n      \"healthcheck_route\": \"/readyz\"\n    },\n    \"model_infra\": {\n      \"endpoint_type\": \"sync\",\n      \"cpus\": 3,\n      \"gpus\": 0,\n      \"memory\": \"8Gi\",\n      \"storage\": \"16Gi\",\n      \"min_workers\": 0,\n      \"max_workers\": 1,\n      \"per_worker\": 10,\n      \"high_priority\": false,\n      \"labels\": {},\n      \"public_inference\": false\n    }\n  },\n  \"model_type\": \"generic\",\n  \"model_vendor\": \"launch\",\n  \"model_metadata\": {},\n  \"on_conflict\": \"error\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.egp.scale.com/v5/models")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"<string>\",\n  \"vendor_configuration\": {\n    \"model_image\": {\n      \"registry\": \"<string>\",\n      \"repository\": \"<string>\",\n      \"tag\": \"<string>\",\n      \"command\": [\n        \"<string>\"\n      ],\n      \"predict_route\": \"/predict\",\n      \"streaming_predict_route\": \"<string>\",\n      \"streaming_command\": [\n        \"<string>\"\n      ],\n      \"request_schema\": {},\n      \"response_schema\": {},\n      \"env_vars\": {},\n      \"readiness_delay\": 120,\n      \"healthcheck_route\": \"/readyz\"\n    },\n    \"model_infra\": {\n      \"endpoint_type\": \"sync\",\n      \"cpus\": 3,\n      \"gpus\": 0,\n      \"memory\": \"8Gi\",\n      \"storage\": \"16Gi\",\n      \"min_workers\": 0,\n      \"max_workers\": 1,\n      \"per_worker\": 10,\n      \"high_priority\": false,\n      \"labels\": {},\n      \"public_inference\": false\n    }\n  },\n  \"model_type\": \"generic\",\n  \"model_vendor\": \"launch\",\n  \"model_metadata\": {},\n  \"on_conflict\": \"error\"\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "name": "<string>",
  "model_type": "generic",
  "model_vendor": "openai",
  "status": "failed",
  "created_at": "2023-11-07T05:31:56Z",
  "created_by_user_id": "<string>",
  "created_by_identity_type": "user",
  "object": "model",
  "vendor_configuration": {
    "model_image": {
      "registry": "<string>",
      "repository": "<string>",
      "tag": "<string>",
      "command": [
        "<string>"
      ],
      "predict_route": "/predict",
      "streaming_predict_route": "<string>",
      "streaming_command": [
        "<string>"
      ],
      "request_schema": {},
      "response_schema": {},
      "env_vars": {},
      "readiness_delay": 120,
      "healthcheck_route": "/readyz"
    },
    "model_infra": {
      "endpoint_type": "sync",
      "cpus": 3,
      "gpus": 0,
      "gpu_type": "nvidia-tesla-t4",
      "memory": "8Gi",
      "storage": "16Gi",
      "min_workers": 0,
      "max_workers": 1,
      "per_worker": 10,
      "high_priority": false,
      "labels": {},
      "public_inference": false
    }
  },
  "status_reason": "<string>",
  "model_metadata": {},
  "model_availability": "unknown"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

Models

Create a custom model

Create a custom model record in your account and begin deploying it through a supported serving vendor.

A model here is a record for a model you deploy and serve through Scale’s own inference vendors: only the launch and llmengine vendors are accepted and any other vendor is rejected. This is distinct from GET /v5/chat/completions/models, which lists the models already available to call for chat completions rather than creating or managing these records. The call is asynchronous — the record is created in a deploying status, a deployment job is recorded, and a Temporal workflow is started to perform the deployment, so the model is not ready for inference when this returns. A model name must be unique per vendor within your account; if a model with the same name and vendor already exists the request fails unless on_conflict is set to update, in which case the existing model is updated instead.

POST

models

curl --request POST \
  --url https://api.egp.scale.com/v5/models \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "name": "<string>",
  "vendor_configuration": {
    "model_image": {
      "registry": "<string>",
      "repository": "<string>",
      "tag": "<string>",
      "command": [
        "<string>"
      ],
      "predict_route": "/predict",
      "streaming_predict_route": "<string>",
      "streaming_command": [
        "<string>"
      ],
      "request_schema": {},
      "response_schema": {},
      "env_vars": {},
      "readiness_delay": 120,
      "healthcheck_route": "/readyz"
    },
    "model_infra": {
      "endpoint_type": "sync",
      "cpus": 3,
      "gpus": 0,
      "memory": "8Gi",
      "storage": "16Gi",
      "min_workers": 0,
      "max_workers": 1,
      "per_worker": 10,
      "high_priority": false,
      "labels": {},
      "public_inference": false
    }
  },
  "model_type": "generic",
  "model_vendor": "launch",
  "model_metadata": {},
  "on_conflict": "error"
}
'

import requests

url = "https://api.egp.scale.com/v5/models"

payload = {
    "name": "<string>",
    "vendor_configuration": {
        "model_image": {
            "registry": "<string>",
            "repository": "<string>",
            "tag": "<string>",
            "command": ["<string>"],
            "predict_route": "/predict",
            "streaming_predict_route": "<string>",
            "streaming_command": ["<string>"],
            "request_schema": {},
            "response_schema": {},
            "env_vars": {},
            "readiness_delay": 120,
            "healthcheck_route": "/readyz"
        },
        "model_infra": {
            "endpoint_type": "sync",
            "cpus": 3,
            "gpus": 0,
            "memory": "8Gi",
            "storage": "16Gi",
            "min_workers": 0,
            "max_workers": 1,
            "per_worker": 10,
            "high_priority": False,
            "labels": {},
            "public_inference": False
        }
    },
    "model_type": "generic",
    "model_vendor": "launch",
    "model_metadata": {},
    "on_conflict": "error"
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    name: '<string>',
    vendor_configuration: {
      model_image: {
        registry: '<string>',
        repository: '<string>',
        tag: '<string>',
        command: ['<string>'],
        predict_route: '/predict',
        streaming_predict_route: '<string>',
        streaming_command: ['<string>'],
        request_schema: {},
        response_schema: {},
        env_vars: {},
        readiness_delay: 120,
        healthcheck_route: '/readyz'
      },
      model_infra: {
        endpoint_type: 'sync',
        cpus: 3,
        gpus: 0,
        memory: '8Gi',
        storage: '16Gi',
        min_workers: 0,
        max_workers: 1,
        per_worker: 10,
        high_priority: false,
        labels: {},
        public_inference: false
      }
    },
    model_type: 'generic',
    model_vendor: 'launch',
    model_metadata: {},
    on_conflict: 'error'
  })
};

fetch('https://api.egp.scale.com/v5/models', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.egp.scale.com/v5/models",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '<string>',
    'vendor_configuration' => [
        'model_image' => [
                'registry' => '<string>',
                'repository' => '<string>',
                'tag' => '<string>',
                'command' => [
                                '<string>'
                ],
                'predict_route' => '/predict',
                'streaming_predict_route' => '<string>',
                'streaming_command' => [
                                '<string>'
                ],
                'request_schema' => [
                                
                ],
                'response_schema' => [
                                
                ],
                'env_vars' => [
                                
                ],
                'readiness_delay' => 120,
                'healthcheck_route' => '/readyz'
        ],
        'model_infra' => [
                'endpoint_type' => 'sync',
                'cpus' => 3,
                'gpus' => 0,
                'memory' => '8Gi',
                'storage' => '16Gi',
                'min_workers' => 0,
                'max_workers' => 1,
                'per_worker' => 10,
                'high_priority' => false,
                'labels' => [
                                
                ],
                'public_inference' => false
        ]
    ],
    'model_type' => 'generic',
    'model_vendor' => 'launch',
    'model_metadata' => [
        
    ],
    'on_conflict' => 'error'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.egp.scale.com/v5/models"

	payload := strings.NewReader("{\n  \"name\": \"<string>\",\n  \"vendor_configuration\": {\n    \"model_image\": {\n      \"registry\": \"<string>\",\n      \"repository\": \"<string>\",\n      \"tag\": \"<string>\",\n      \"command\": [\n        \"<string>\"\n      ],\n      \"predict_route\": \"/predict\",\n      \"streaming_predict_route\": \"<string>\",\n      \"streaming_command\": [\n        \"<string>\"\n      ],\n      \"request_schema\": {},\n      \"response_schema\": {},\n      \"env_vars\": {},\n      \"readiness_delay\": 120,\n      \"healthcheck_route\": \"/readyz\"\n    },\n    \"model_infra\": {\n      \"endpoint_type\": \"sync\",\n      \"cpus\": 3,\n      \"gpus\": 0,\n      \"memory\": \"8Gi\",\n      \"storage\": \"16Gi\",\n      \"min_workers\": 0,\n      \"max_workers\": 1,\n      \"per_worker\": 10,\n      \"high_priority\": false,\n      \"labels\": {},\n      \"public_inference\": false\n    }\n  },\n  \"model_type\": \"generic\",\n  \"model_vendor\": \"launch\",\n  \"model_metadata\": {},\n  \"on_conflict\": \"error\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.egp.scale.com/v5/models")
  .header("x-api-key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"<string>\",\n  \"vendor_configuration\": {\n    \"model_image\": {\n      \"registry\": \"<string>\",\n      \"repository\": \"<string>\",\n      \"tag\": \"<string>\",\n      \"command\": [\n        \"<string>\"\n      ],\n      \"predict_route\": \"/predict\",\n      \"streaming_predict_route\": \"<string>\",\n      \"streaming_command\": [\n        \"<string>\"\n      ],\n      \"request_schema\": {},\n      \"response_schema\": {},\n      \"env_vars\": {},\n      \"readiness_delay\": 120,\n      \"healthcheck_route\": \"/readyz\"\n    },\n    \"model_infra\": {\n      \"endpoint_type\": \"sync\",\n      \"cpus\": 3,\n      \"gpus\": 0,\n      \"memory\": \"8Gi\",\n      \"storage\": \"16Gi\",\n      \"min_workers\": 0,\n      \"max_workers\": 1,\n      \"per_worker\": 10,\n      \"high_priority\": false,\n      \"labels\": {},\n      \"public_inference\": false\n    }\n  },\n  \"model_type\": \"generic\",\n  \"model_vendor\": \"launch\",\n  \"model_metadata\": {},\n  \"on_conflict\": \"error\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.egp.scale.com/v5/models")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"<string>\",\n  \"vendor_configuration\": {\n    \"model_image\": {\n      \"registry\": \"<string>\",\n      \"repository\": \"<string>\",\n      \"tag\": \"<string>\",\n      \"command\": [\n        \"<string>\"\n      ],\n      \"predict_route\": \"/predict\",\n      \"streaming_predict_route\": \"<string>\",\n      \"streaming_command\": [\n        \"<string>\"\n      ],\n      \"request_schema\": {},\n      \"response_schema\": {},\n      \"env_vars\": {},\n      \"readiness_delay\": 120,\n      \"healthcheck_route\": \"/readyz\"\n    },\n    \"model_infra\": {\n      \"endpoint_type\": \"sync\",\n      \"cpus\": 3,\n      \"gpus\": 0,\n      \"memory\": \"8Gi\",\n      \"storage\": \"16Gi\",\n      \"min_workers\": 0,\n      \"max_workers\": 1,\n      \"per_worker\": 10,\n      \"high_priority\": false,\n      \"labels\": {},\n      \"public_inference\": false\n    }\n  },\n  \"model_type\": \"generic\",\n  \"model_vendor\": \"launch\",\n  \"model_metadata\": {},\n  \"on_conflict\": \"error\"\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "name": "<string>",
  "model_type": "generic",
  "model_vendor": "openai",
  "status": "failed",
  "created_at": "2023-11-07T05:31:56Z",
  "created_by_user_id": "<string>",
  "created_by_identity_type": "user",
  "object": "model",
  "vendor_configuration": {
    "model_image": {
      "registry": "<string>",
      "repository": "<string>",
      "tag": "<string>",
      "command": [
        "<string>"
      ],
      "predict_route": "/predict",
      "streaming_predict_route": "<string>",
      "streaming_command": [
        "<string>"
      ],
      "request_schema": {},
      "response_schema": {},
      "env_vars": {},
      "readiness_delay": 120,
      "healthcheck_route": "/readyz"
    },
    "model_infra": {
      "endpoint_type": "sync",
      "cpus": 3,
      "gpus": 0,
      "gpu_type": "nvidia-tesla-t4",
      "memory": "8Gi",
      "storage": "16Gi",
      "min_workers": 0,
      "max_workers": 1,
      "per_worker": 10,
      "high_priority": false,
      "labels": {},
      "public_inference": false
    }
  },
  "status_reason": "<string>",
  "model_metadata": {},
  "model_availability": "unknown"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

Authorizations

x-api-key

string

header

required

Headers

x-selected-account-id

string | null

Body

application/json

LaunchModelCreateRequest
LLMEngineModelCreateRequest
HostedModelCreateRequest

name

string

required

Unique name to reference your model

vendor_configuration

LaunchVendorConfiguration · object

required

Show child attributes

model_type

string

default:generic

Allowed value: "generic"

model_vendor

string

default:launch

Allowed value: "launch"

model_metadata

Model Metadata · object | null

on_conflict

enum<string>

default:error

Available options:

error,

update

Response

Successful Response

string

required

The unique identifier of the entity.

name

string

required

model_type

enum<string>

required

Available options:

generic,

completion,

chat_completion

model_vendor

enum<string>

required

Available options:

openai,

cohere,

vertex_ai,

anthropic,

azure,

gemini,

launch,

llmengine,

model_zoo,

bedrock,

xai,

fireworks_ai,

oci

status

enum<string>

required

Available options:

failed,

ready,

deploying,

deployment_timeout

created_at

string<date-time>

required

The date and time when the entity was created in ISO format.

created_by_user_id

string

required

The user who originally created the entity.

created_by_identity_type

enum<string>

required

The type of identity that created the entity.

Available options:

user,

service_account

object

string

default:model

Allowed value: "model"

vendor_configuration

LaunchVendorConfiguration · object

LaunchVendorConfiguration
LLMEngineVendorConfiguration

Show child attributes

status_reason

string | null

model_metadata

Model Metadata · object | null

model_availability

enum<string> | null

Available options:

unknown,

available,

unavailable

Inference

Questions

Rubrics

Vector Stores

Files

Models

Agent Configs

Datasets

Dataset Items

Evaluations

Evaluation Groups

Evaluation Charts

Evaluation Dashboards

Evaluation Items

Spans

Span Assessment

Annotation Tasks

Credentials

Agentex Cloud Build

Agentex Cloud Deploy

Agentex Agent

SGP Cloud Secrets

Create a custom model

Authorizations

Headers

Body

Response