> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.umnai.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.umnai.com/_mcp/server.

# Compute

Compute configurations let you choose the machine resources used for long-running platform jobs.

Use **processing** compute for ingestion and onboarding. Use **training** compute for model training. Create each configuration once, then reuse its `id` in the workflows that need it.

## How it works

Each compute configuration has a name, a workload type, and a machine type.

| Field          | Description                                                                 |
| -------------- | --------------------------------------------------------------------------- |
| `name`         | A readable name for the configuration.                                      |
| `compute_type` | The workload the configuration is used for. Use `PROCESSING` or `TRAINING`. |
| `machine_type` | The machine type used to run the job.                                       |

Larger machine types can help with larger workloads or faster jobs, but they may increase cost.

## Create a processing configuration

Processing configurations are used by ingestion and onboarding workflows.

First, retrieve the available processing machine types. Choose one of the returned `name` values for `machine_type`.

### Request

GET [https://api.hi.umnai.com/machine-types](https://api.hi.umnai.com/machine-types)

```curl Retrieve processing machine types
curl https://api.hi.umnai.com/machine-types \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json"
```

```python Retrieve processing machine types
import requests

url = "https://api.hi.umnai.com/machine-types"

payload = { "queryParameters": { "component": "PROCESSING" } }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Retrieve processing machine types
const url = 'https://api.hi.umnai.com/machine-types';
const options = {
  method: 'GET',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"queryParameters":{"component":"PROCESSING"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Retrieve processing machine types
package main

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

func main() {

	url := "https://api.hi.umnai.com/machine-types"

	payload := strings.NewReader("{\n  \"queryParameters\": {\n    \"component\": \"PROCESSING\"\n  }\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Retrieve processing machine types
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/machine-types")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"queryParameters\": {\n    \"component\": \"PROCESSING\"\n  }\n}"

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

```java Retrieve processing machine types
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.hi.umnai.com/machine-types")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"queryParameters\": {\n    \"component\": \"PROCESSING\"\n  }\n}")
  .asString();
```

```php Retrieve processing machine types
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hi.umnai.com/machine-types', [
  'body' => '{
  "queryParameters": {
    "component": "PROCESSING"
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Retrieve processing machine types
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/machine-types");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"queryParameters\": {\n    \"component\": \"PROCESSING\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Retrieve processing machine types
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["queryParameters": ["component": "PROCESSING"]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/machine-types")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (200)

```json
{
  "data": [
    {
      "name": "ml.m5.4xlarge",
      "cpus": 16,
      "cpu_memory_gb": 64,
      "created_at": "2026-03-15T10:15:30.000000Z",
      "component": "PROCESSING",
      "gpus": 0,
      "gpu_memory_gb": 0
    },
    {
      "name": "ml.m5.8xlarge",
      "cpus": 32,
      "cpu_memory_gb": 128,
      "created_at": "2026-03-15T10:15:30.000000Z",
      "component": "PROCESSING",
      "gpus": 0,
      "gpu_memory_gb": 0
    }
  ],
  "pagination": {
    "total_items": 2,
    "items_per_page": 2,
    "current_page": 1,
    "total_pages": 1
  }
}
```

Then create the compute configuration with `compute_type: "PROCESSING"`.

### Request

POST [https://api.hi.umnai.com/compute-configurations](https://api.hi.umnai.com/compute-configurations)

```curl Processing compute configuration
curl -X POST https://api.hi.umnai.com/compute-configurations \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "name": "Sample Compute Configuration",
  "compute_type": "PROCESSING",
  "machine_type": "ml.m5.4xlarge"
}'
```

```python Processing compute configuration
import requests

url = "https://api.hi.umnai.com/compute-configurations"

payload = {
    "name": "Sample Compute Configuration",
    "compute_type": "PROCESSING",
    "machine_type": "ml.m5.4xlarge"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Processing compute configuration
const url = 'https://api.hi.umnai.com/compute-configurations';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"name":"Sample Compute Configuration","compute_type":"PROCESSING","machine_type":"ml.m5.4xlarge"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Processing compute configuration
package main

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

func main() {

	url := "https://api.hi.umnai.com/compute-configurations"

	payload := strings.NewReader("{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"PROCESSING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Processing compute configuration
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/compute-configurations")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"PROCESSING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}"

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

```java Processing compute configuration
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.hi.umnai.com/compute-configurations")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"PROCESSING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}")
  .asString();
```

```php Processing compute configuration
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.hi.umnai.com/compute-configurations', [
  'body' => '{
  "name": "Sample Compute Configuration",
  "compute_type": "PROCESSING",
  "machine_type": "ml.m5.4xlarge"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Processing compute configuration
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/compute-configurations");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"PROCESSING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Processing compute configuration
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Sample Compute Configuration",
  "compute_type": "PROCESSING",
  "machine_type": "ml.m5.4xlarge"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/compute-configurations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (201)

```json
{
  "id": "351df95006b1350e597762a1d58e9319",
  "name": "Sample Compute Configuration",
  "machine_type": "ml.m5.4xlarge",
  "compute_type": "PROCESSING",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-25T15:23:50.965824Z",
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  },
  "updated_at": null
}
```

Save the returned `id`. You will use it when creating ingestion and onboarding configurations.

## Create a training configuration

Training configurations are used by model training workflows.

First, retrieve the available training machine types. Choose one of the returned `name` values for `machine_type`.

### Request

GET [https://api.hi.umnai.com/machine-types](https://api.hi.umnai.com/machine-types)

```curl Retrieve training machine types
curl https://api.hi.umnai.com/machine-types \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json"
```

```python Retrieve training machine types
import requests

url = "https://api.hi.umnai.com/machine-types"

payload = { "queryParameters": { "component": "TRAINING" } }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Retrieve training machine types
const url = 'https://api.hi.umnai.com/machine-types';
const options = {
  method: 'GET',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"queryParameters":{"component":"TRAINING"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Retrieve training machine types
package main

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

func main() {

	url := "https://api.hi.umnai.com/machine-types"

	payload := strings.NewReader("{\n  \"queryParameters\": {\n    \"component\": \"TRAINING\"\n  }\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Retrieve training machine types
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/machine-types")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"queryParameters\": {\n    \"component\": \"TRAINING\"\n  }\n}"

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

```java Retrieve training machine types
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.hi.umnai.com/machine-types")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"queryParameters\": {\n    \"component\": \"TRAINING\"\n  }\n}")
  .asString();
```

```php Retrieve training machine types
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hi.umnai.com/machine-types', [
  'body' => '{
  "queryParameters": {
    "component": "TRAINING"
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Retrieve training machine types
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/machine-types");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"queryParameters\": {\n    \"component\": \"TRAINING\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Retrieve training machine types
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["queryParameters": ["component": "TRAINING"]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/machine-types")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (200)

```json
{
  "data": [
    {
      "name": "ml.m5.4xlarge",
      "cpus": 16,
      "cpu_memory_gb": 64,
      "created_at": "2026-03-15T10:15:30.000000Z",
      "component": "TRAINING",
      "gpus": 0,
      "gpu_memory_gb": 0
    },
    {
      "name": "ml.g5.4xlarge",
      "cpus": 16,
      "cpu_memory_gb": 64,
      "created_at": "2026-03-15T10:15:30.000000Z",
      "component": "TRAINING",
      "gpus": 1,
      "gpu_memory_gb": 24
    }
  ],
  "pagination": {
    "total_items": 2,
    "items_per_page": 2,
    "current_page": 1,
    "total_pages": 1
  }
}
```

Then create the compute configuration with `compute_type: "TRAINING"`.

### Request

POST [https://api.hi.umnai.com/compute-configurations](https://api.hi.umnai.com/compute-configurations)

```curl Training compute configuration
curl -X POST https://api.hi.umnai.com/compute-configurations \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "name": "Sample Compute Configuration",
  "compute_type": "TRAINING",
  "machine_type": "ml.m5.4xlarge"
}'
```

```python Training compute configuration
import requests

url = "https://api.hi.umnai.com/compute-configurations"

payload = {
    "name": "Sample Compute Configuration",
    "compute_type": "TRAINING",
    "machine_type": "ml.m5.4xlarge"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Training compute configuration
const url = 'https://api.hi.umnai.com/compute-configurations';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"name":"Sample Compute Configuration","compute_type":"TRAINING","machine_type":"ml.m5.4xlarge"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Training compute configuration
package main

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

func main() {

	url := "https://api.hi.umnai.com/compute-configurations"

	payload := strings.NewReader("{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"TRAINING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Training compute configuration
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/compute-configurations")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"TRAINING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}"

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

```java Training compute configuration
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.hi.umnai.com/compute-configurations")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"TRAINING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}")
  .asString();
```

```php Training compute configuration
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.hi.umnai.com/compute-configurations', [
  'body' => '{
  "name": "Sample Compute Configuration",
  "compute_type": "TRAINING",
  "machine_type": "ml.m5.4xlarge"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp Training compute configuration
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/compute-configurations");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Sample Compute Configuration\",\n  \"compute_type\": \"TRAINING\",\n  \"machine_type\": \"ml.m5.4xlarge\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Training compute configuration
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Sample Compute Configuration",
  "compute_type": "TRAINING",
  "machine_type": "ml.m5.4xlarge"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/compute-configurations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (201)

```json
{
  "id": "351df95006b1350e597762a1d58e9319",
  "name": "Sample Compute Configuration",
  "machine_type": "ml.m5.4xlarge",
  "compute_type": "TRAINING",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-25T15:23:50.965824Z",
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  },
  "updated_at": null
}
```

Save the returned `id`. You will use it when creating training configurations.