Manage resources

Use these examples alongside Run a fine-tune job, Deploy a model server, and Reinforcement learning. Those guides cover creating workloads; this page covers shared resource management. The examples assume an initialized sdk client and an authenticated MKA1 CLI.

Inspect an accelerator

Use a name returned by the accelerator catalog.

const result = await sdk.computeCatalog.getAccelerator({
  "name": "nvidia-rtx-4090-24gb"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.name);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeCatalog.GetAcceleratorAsync(name: "nvidia-rtx-4090-24gb");
var result = response.ComputeAccelerator
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Name));

from meetkai_mka1 import models

result = sdk.compute_catalog.get_accelerator(
    name="nvidia-rtx-4090-24gb",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.name)

curl "https://apigw.mka1.com/api/v1/compute/catalog/accelerators/nvidia-rtx-4090-24gb" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-catalog get-accelerator \
  --name nvidia-rtx-4090-24gb \
  --output-format json

Inspect offers

Availability is an observation, not a reservation. Detailed offer and provider discovery can be unavailable on deployments that hide provider information; use the public quote operation in that case.

const result = await sdk.computeCatalog.listComputeOffers({
  "accelerator": "nvidia-rtx-4090-24gb",
  "gpuCount": 1
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var request = new ListComputeOffersRequest
{
    Accelerator = "nvidia-rtx-4090-24gb",
    GpuCount = 1,
    Limit = 50,
};

var response = await sdk.ComputeCatalog.ListComputeOffersAsync(request);
var result = response.ComputeOfferList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_catalog.list_compute_offers(
    accelerator="nvidia-rtx-4090-24gb",
    gpu_count=1,
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/catalog/offers?accelerator=nvidia-rtx-4090-24gb&gpu_count=1" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-catalog list-compute-offers \
  --accelerator nvidia-rtx-4090-24gb \
  --gpu-count 1 \
  --limit 50 \
  --output-format json

Inspect providers

Provider entries describe the configured backend; they do not promise capacity for a particular job.

const result = await sdk.computeCatalog.listComputeProviders({});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeCatalog.ListComputeProvidersAsync();
var result = response.ComputeProviderHealthList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_catalog.list_compute_providers()
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/catalog/providers" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-catalog list-compute-providers \
  --limit 50 \
  --output-format json

List jobs

Read the first page. For subsequent pages, pass the returned next_cursor as cursor until it is null. The SDK does not automatically traverse these lists.

const result = await sdk.computeJobs.listJobs({
  "limit": 20
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeJobs.ListJobsAsync(limit: 20);
var result = response.ComputeJobList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_jobs.list_jobs(
    limit=20,
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/jobs?limit=20" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-jobs list-jobs \
  --limit 20 \
  --output-format json

List services

Use the same cursor pattern for services.

const result = await sdk.computeServices.listServices({
  "limit": 20
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeServices.ListServicesAsync(limit: 20);
var result = response.ComputeServiceList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_services.list_services(
    limit=20,
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/services?limit=20" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-services list-services \
  --limit 20 \
  --output-format json

Inspect job instances

Instance observations describe the hardware associated with a job; use them alongside lifecycle events when diagnosing provisioning.

const result = await sdk.computeJobs.listJobInstances({
  "id": "job_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var request = JsonConvert.DeserializeObject<ListJobInstancesRequest> ("""
{
  "id": "job_REPLACE"
}
""")!;

var response = await sdk.ComputeJobs.ListJobInstancesAsync(request);
var result = response.ComputeInstanceList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_jobs.list_job_instances(
    id="job_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/jobs/job_REPLACE/instances" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-jobs list-job-instances \
  --id job_REPLACE \
  --limit 50 \
  --order asc \
  --output-format json

Read service logs

Use source=user for application output or source=system for allocation and bootstrap output. Pass next_cursor as cursor to read more.

const result = await sdk.computeServices.listServiceLogs({
  "source": "user",
  "order": "desc",
  "limit": 50,
  "id": "service_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var request = JsonConvert.DeserializeObject<ListServiceLogsRequest> ("""
{
  "source": "user",
  "order": "desc",
  "limit": 50,
  "id": "service_REPLACE"
}
""")!;

var response = await sdk.ComputeServices.ListServiceLogsAsync(request);
var result = response.ComputeLogList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_services.list_service_logs(
    source="user",
    order="desc",
    limit=50,
    id="service_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/services/service_REPLACE/logs?source=user&order=desc&limit=50" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-services list-service-logs \
  --id service_REPLACE \
  --limit 50 \
  --order desc \
  --source user \
  --output-format json

Read service events

Events describe lifecycle transitions. They are distinct from your server logs.

const result = await sdk.computeServices.listServiceEvents({
  "id": "service_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var request = JsonConvert.DeserializeObject<ListServiceEventsRequest> ("""
{
  "id": "service_REPLACE"
}
""")!;

var response = await sdk.ComputeServices.ListServiceEventsAsync(request);
var result = response.ComputeEventList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_services.list_service_events(
    id="service_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/services/service_REPLACE/events" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-services list-service-events \
  --id service_REPLACE \
  --limit 50 \
  --order asc \
  --output-format json

Inspect service instances

Inspect the observed instances for this service.

const result = await sdk.computeServices.listServiceInstances({
  "id": "service_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var request = JsonConvert.DeserializeObject<ListServiceInstancesRequest> ("""
{
  "id": "service_REPLACE"
}
""")!;

var response = await sdk.ComputeServices.ListServiceInstancesAsync(request);
var result = response.ComputeInstanceList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_services.list_service_instances(
    id="service_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/services/service_REPLACE/instances" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-services list-service-instances \
  --id service_REPLACE \
  --limit 50 \
  --order asc \
  --output-format json

List secrets

Only names, IDs, and key names are readable; stored values are not returned.

const result = await sdk.computeSecrets.listComputeSecrets({
  "limit": 20
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeSecrets.ListComputeSecretsAsync(limit: 20);
var result = response.ComputeSecretList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_secrets.list_compute_secrets(
    limit=20,
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/secrets?limit=20" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-secrets list \
  --limit 20 \
  --output-format json

Inspect a secret

Use the returned key names when configuring container.secret_env.

const result = await sdk.computeSecrets.getComputeSecret({
  "id": "sec_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.keys);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeSecrets.GetComputeSecretAsync("sec_REPLACE");
var result = response.ComputeSecret
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Keys));

from meetkai_mka1 import models

result = sdk.compute_secrets.get_compute_secret(
    id="sec_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.keys)

curl "https://apigw.mka1.com/api/v1/compute/secrets/sec_REPLACE" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-secrets get \
  --id sec_REPLACE \
  --output-format json

Delete a secret

Delete a secret only when it is no longer needed for new workloads or provisioning. This removes the stored credential; it does not terminate existing jobs or services.

const result = await sdk.computeSecrets.deleteComputeSecret({
  "id": "sec_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log('Request completed');

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeSecrets.DeleteComputeSecretAsync("sec_REPLACE");
Console.WriteLine("Request completed");

from meetkai_mka1 import models

result = sdk.compute_secrets.delete_compute_secret(
    id="sec_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print("Request completed")

curl "https://apigw.mka1.com/api/v1/compute/secrets/sec_REPLACE" \
  --request DELETE \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-secrets delete \
  --id sec_REPLACE \
  --output-format json

Create a shared volume

Standalone volumes provide persistent shared storage on compatible placements. Confirm your deployment supports this capability before using it; a volume is not portable to every GPU provider. Creating and retaining storage can accrue charges independently of jobs.

// Keep this value unchanged when retrying this request.
const idempotencyKey = process.env.MKA1_REQUEST_ID;
if (!idempotencyKey) throw new Error('Set MKA1_REQUEST_ID');

const result = await sdk.computeVolumes.createStandaloneVolume({
  "idempotencyKey": idempotencyKey,
  "computeStandaloneVolumeCreate": {
    "name": "training-data"
  }
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.id);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var idempotencyKey = System.Environment.GetEnvironmentVariable("MKA1_REQUEST_ID")
    ?? throw new InvalidOperationException("Set MKA1_REQUEST_ID");

// Deserialize the wire-format payload into the SDK request model.
var body = JsonConvert.DeserializeObject<MeetKai.MKA1.Types.Components.ComputeStandaloneVolumeCreate> ("""
{
  "name": "training-data"
}
""")!;

var response = await sdk.ComputeVolumes.CreateStandaloneVolumeAsync(idempotencyKey, body);
var result = response.ComputeStandaloneVolume
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Id));

import os
from meetkai_mka1 import models

idempotency_key = os.environ["MKA1_REQUEST_ID"]  # Reuse for retries.

result = sdk.compute_volumes.create_standalone_volume(
    idempotency_key=idempotency_key,
    name="training-data",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.id)

curl "https://apigw.mka1.com/api/v1/compute/volumes" \
  --request POST \
  --header "Authorization: Bearer $MKA1_API_KEY" \
  --header "Idempotency-Key: $MKA1_REQUEST_ID" \
  --header 'Content-Type: application/json' \
  --data '{"name": "training-data"}'

mka1 compute-volumes create-standalone-volume \
  --idempotency-key "$MKA1_REQUEST_ID" \
  --output-format json \
  --body @- <<'JSON'
{
  "name": "training-data"
}
JSON

List volumes

Volumes are scoped to your organization.

const result = await sdk.computeVolumes.listStandaloneVolumes({
  "limit": 20
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeVolumes.ListStandaloneVolumesAsync(limit: 20);
var result = response.ComputeStandaloneVolumeList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_volumes.list_standalone_volumes(
    limit=20,
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/volumes?limit=20" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-volumes list-standalone-volumes \
  --limit 20 \
  --output-format json

Inspect a volume

Check volume state before launching a workload that depends on it.

const result = await sdk.computeVolumes.getStandaloneVolume({
  "id": "vol_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.status);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeVolumes.GetStandaloneVolumeAsync("vol_REPLACE");
var result = response.ComputeStandaloneVolume
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Status));

from meetkai_mka1 import models

result = sdk.compute_volumes.get_standalone_volume(
    id="vol_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.status)

curl "https://apigw.mka1.com/api/v1/compute/volumes/vol_REPLACE" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-volumes get-standalone-volume \
  --id vol_REPLACE \
  --output-format json

Inspect volume attachments

Attachments show the workloads that reference a volume.

const result = await sdk.computeVolumes.listStandaloneVolumeAttachments({
  "id": "vol_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.data);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var request = JsonConvert.DeserializeObject<ListStandaloneVolumeAttachmentsRequest> ("""
{
  "id": "vol_REPLACE"
}
""")!;

var response = await sdk.ComputeVolumes.ListStandaloneVolumeAttachmentsAsync(request);
var result = response.ComputeStandaloneVolumeAttachmentList
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Data));

from meetkai_mka1 import models

result = sdk.compute_volumes.list_standalone_volume_attachments(
    id="vol_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.data)

curl "https://apigw.mka1.com/api/v1/compute/volumes/vol_REPLACE/attachments" \
  --request GET \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-volumes list-standalone-volume-attachments \
  --id vol_REPLACE \
  --limit 50 \
  --output-format json

Delete a volume

This permanently deletes its data. Terminate attached workloads and wait for their attachments to become terminal first; deletion is refused while non-terminal attachments exist.

const result = await sdk.computeVolumes.deleteStandaloneVolume({
  "id": "vol_REPLACE"
});
if (result && 'error' in result) throw new Error(JSON.stringify(result.error));
console.log(result.status);

using MeetKai.MKA1.Types.Components;
using MeetKai.MKA1.Types.Requests;
using Newtonsoft.Json;

var response = await sdk.ComputeVolumes.DeleteStandaloneVolumeAsync("vol_REPLACE");
var result = response.ComputeStandaloneVolume
    ?? throw new InvalidOperationException(JsonConvert.SerializeObject(response));
Console.WriteLine(JsonConvert.SerializeObject(result.Status));

from meetkai_mka1 import models

result = sdk.compute_volumes.delete_standalone_volume(
    id="vol_REPLACE",
)
if isinstance(result, models.ComputeErrorEnvelope):
    raise RuntimeError(result.error)
print(result.status)

curl "https://apigw.mka1.com/api/v1/compute/volumes/vol_REPLACE" \
  --request DELETE \
  --header "Authorization: Bearer $MKA1_API_KEY"

mka1 compute-volumes delete-standalone-volume \
  --id vol_REPLACE \
  --output-format json

Mount a volume in a workload

Add the following field to the complete job or service creation body from the workload guides, using a placement compatible with the volume:

Volume mount field

{
  "volumes": [
    {"volume_id": "vol_REPLACE", "mount_path": "/workspace/data"}
  ]
}

This is a request fragment, not a complete create request. The TypeScript SDK uses volumeId and mountPath; Python uses volume_id and mount_path. C# uses ComputeStandaloneVolumeMount with VolumeId and MountPath. Your container must read and write under the mount path to use persistent storage. For workflows on external GPU capacity without compatible volume support, publish artifacts to repositories.

Usage and administration

Use the job usage or service usage examples; select volume as the resource type to inspect volume usage where supported. Tenant enablement and pricing administration require elevated permissions. Their complete schemas are in the Compute Tenants and Compute Pricing groups of the API reference.

Getting started

Responses

Features

Compute

CLI

Recipes

Benchmarks

Infrastructure

Manage resources

Inspect an accelerator

Inspect offers

Inspect providers

List jobs

List services

Inspect job instances

Read service logs

Read service events

Inspect service instances

List secrets

Inspect a secret

Delete a secret

Create a shared volume

List volumes

Inspect a volume

Inspect volume attachments

Delete a volume

Mount a volume in a workload

Usage and administration

​Inspect an accelerator

​Inspect offers

​Inspect providers

​List jobs

​List services

​Inspect job instances

​Read service logs

​Read service events

​Inspect service instances

​List secrets

​Inspect a secret

​Delete a secret

​Create a shared volume

​List volumes

​Inspect a volume

​Inspect volume attachments

​Delete a volume

​Mount a volume in a workload

​Usage and administration

Inspect an accelerator

Inspect offers

Inspect providers

List jobs

List services

Inspect job instances

Read service logs

Read service events

Inspect service instances

List secrets

Inspect a secret

Delete a secret

Create a shared volume

List volumes

Inspect a volume

Inspect volume attachments

Delete a volume

Mount a volume in a workload

Usage and administration