Getting Started

import type { ResponseObject } from '@meetkai/mka1/models/components';

const result = await mka1.llm.responses.create({
  xOnBehalfOf: 'user_123',
  responsesCreateRequest: {
    model: 'auto',
    input: 'Summarize this support ticket.',
  },
}) as ResponseObject;
console.log(result.outputText);

response = sdk.llm.responses.create(
    model="auto",
    input="Summarize this support ticket.",
    x_on_behalf_of="user_123",
)

curl -X POST https://apigw.mka1.com/api/v1/authentication/api-keys/exchange-token \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{ "audience": "https://your-app.example.com", "externalUserId": "user_123" }'
# → { "token": "<jwt>" } — then send Authorization: Bearer <jwt>

const jwt = await mka1.auth.apiKeys.exchangeToken({
  requestBody: {
    audience: 'https://your-app.example.com',
    externalUserId: 'user_123',
  },
});

// jwt.token is the short-lived JWT — use it as the bearer
const asEndUser = new SDK({ bearerAuth: `Bearer ${jwt.token}` });

jwt = sdk.auth.api_keys.exchange_token(body={
    "audience": "https://your-app.example.com",
    "external_user_id": "user_123",
})

# jwt.token is the short-lived JWT — use it as the bearer
as_end_user = SDK(bearer_auth=f"Bearer {jwt.token}")

mka1 llm responses create \
  --model auto \
  --input '"What is the capital of France?"' \
  -H 'X-On-Behalf-Of: <end-user-id>'

import { SDK } from '@meetkai/mka1';
import type { ResponseObject } from '@meetkai/mka1/models/components';

const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' });

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'auto',
    input: 'What is the capital of France?',
  },
}) as ResponseObject;
console.log(result.outputText);

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

res = sdk.llm.responses.create(
    model="auto",
    input="What is the capital of France?",
)

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{ "model": "auto", "input": "What is the capital of France?" }'

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({
  bearerAuth: `Bearer ${YOUR_API_KEY}`,
});

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'auto',
    input: 'Write a one-sentence summary of the MKA1 API.',
  },
});

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

res = sdk.llm.responses.create(
    model="auto",
    input="Write a one-sentence summary of the MKA1 API.",
    http_headers={"X-On-Behalf-Of": "<end-user-id>"},
)

import { CreateAcceptEnum } from '@meetkai/mka1/sdk/responses';
import { EventStream } from '@meetkai/mka1/lib/event-streams';

const stream = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'auto',
    input: 'Write three release notes bullets for our docs update.',
    stream: true,
  },
}, { acceptHeaderOverride: CreateAcceptEnum.textEventStream });

if (stream instanceof EventStream) {
  for await (const event of stream) {
    if (event.data.type === 'response.output_text.delta') {
      process.stdout.write(event.data.delta);
    }
  }
}

stream = sdk.llm.responses.create(
    model="auto",
    input="Write three release notes bullets for our docs update.",
    stream=True,
)

for event in stream:
    if event.data.type == "response.output_text.delta":
        print(event.data.delta, end="", flush=True)

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'openai:gpt-4.1', // vision-capable — 'auto' drops images today
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Describe what you see in this image.' },
          {
            type: 'input_image',
            imageUrl: 'https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg',
          },
        ],
      },
    ],
  },
});

res = sdk.llm.responses.create(
    model="openai:gpt-4.1",  # vision-capable — 'auto' drops images today
    input=[
        {
            "type": "message",
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe what you see in this image."},
                {
                    "type": "input_image",
                    "image_url": "https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg",
                },
            ],
        },
    ],
    x_on_behalf_of="<end-user-id>",
)

import type { ResponseObject } from '@meetkai/mka1/models/components';

const queued = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'auto',
    input: 'Write a two-sentence history of the fax machine.',
    background: true,
    stream: false,
  },
}) as ResponseObject;

// queued.status === 'queued'

let response = queued;
while (response.status === 'queued' || response.status === 'in_progress') {
  await new Promise((r) => setTimeout(r, 2000));
  response = await mka1.llm.responses.get({ responseId: queued.id }) as ResponseObject;
}
console.log(response.outputText);

import time

queued = sdk.llm.responses.create(
    model="auto",
    input="Write a two-sentence history of the fax machine.",
    background=True,
    stream=False,
)  # queued.status == "queued"

response = queued
while response.status in ("queued", "in_progress"):
    time.sleep(2)
    response = sdk.llm.responses.get(response_id=queued.id)

print(response.output_text)

const queued = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'auto',
    input: 'Summarize this 80-page report…',
    background: true,
    stream: false,
    webhookUrl: 'https://your-app.example.com/hooks/mka1',
    webhookSecret: process.env.MKA1_WEBHOOK_SECRET,
  },
}) as ResponseObject;

import os

queued = sdk.llm.responses.create(
    model="auto",
    input="Summarize this 80-page report…",
    background=True,
    stream=False,
    webhook_url="https://your-app.example.com/hooks/mka1",
    webhook_secret=os.environ["MKA1_WEBHOOK_SECRET"],
)

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({ bearerAuth: `Bearer ${YOUR_API_KEY}` });

// 1. Create a conversation (optional metadata for your own routing)
const conv = await mka1.llm.conversations.create({
  xOnBehalfOf: '<end-user-id>',
  createConversationRequest: {
    metadata: { session_id: 'web-42', channel: 'support' },
  },
});

// 2. (Optional) write history explicitly before calling Responses
await mka1.llm.conversations.createItems({
  conversationId: conv.id,
  xOnBehalfOf: '<end-user-id>',
  createItemsRequest: {
    items: [
      { type: 'message', role: 'user', content: 'Summarize the latest support ticket.' },
    ],
  },
});

// 3. Continue the flow — attach the conversation so the model has history
const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'auto',
    conversation: conv.id,
    input: 'Turn that summary into a customer-ready reply.',
  },
});

# 1. Create a conversation (optional metadata for your own routing)
conv = sdk.llm.conversations.create(
    metadata={"session_id": "web-42", "channel": "support"},
    x_on_behalf_of="<end-user-id>",
)

# 2. (Optional) write history explicitly before calling Responses
sdk.llm.conversations.create_items(
    conversation_id=conv.id,
    items=[
        {"type": "message", "role": "user", "content": "Summarize the latest support ticket."},
    ],
    x_on_behalf_of="<end-user-id>",
)

# 3. Continue the flow — attach the conversation so the model has history
result = sdk.llm.responses.create(
    model="auto",
    conversation=conv.id,
    input="Turn that summary into a customer-ready reply.",
)

// Session 1: store a fact
await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'auto',
    input: 'Remember this: my favorite color is blue.',
    tools: [{ type: 'history' }],
    store: true,
  },
});

// Session 2 (minutes or days later — indexing takes ~1–2 min): recall it
const recalled = await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'auto',
    input: 'What is my favorite color?',
    tools: [{ type: 'history' }],
    store: true,
  },
});
// → "Your favorite color is blue."

# Session 1: store a fact
sdk.llm.responses.create(
    model="auto",
    input="Remember this: my favorite color is blue.",
    tools=[{"type": "history"}],
    store=True,
    x_on_behalf_of="user-123",
)

# Session 2 (minutes or days later — indexing takes ~1–2 min): recall it
recalled = sdk.llm.responses.create(
    model="auto",
    input="What is my favorite color?",
    tools=[{"type": "history"}],
    store=True,
    x_on_behalf_of="user-123",
)

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

const file = Bun.file('./support-manual.pdf');

const result = await mka1.llm.files.upload({
  xOnBehalfOf: '<end-user-id>',
  requestBody: { file, purpose: 'assistants' },
});
// result.id → e.g. file_1783478060914_iemq10dh5h

with open("support-manual.pdf", "rb") as fh:
    result = sdk.llm.files.upload(
        file={"file_name": "support-manual.pdf", "content": fh.read()},
        purpose="assistants",
        x_on_behalf_of="<end-user-id>",
    )
# result.id → e.g. file_1783481291595_r19s7ueog7o

const vectorStore = await mka1.llm.vectorStores.create({
  xOnBehalfOf: '<end-user-id>',
  createVectorStoreRequest: {
    name: 'Support knowledge base',
    description: 'Indexed support manuals and help center docs',
    fileIds: [result.id],
    expiresAfter: { anchor: 'last_active_at', days: 30 },
  },
});

vector_store = sdk.llm.vector_stores.create(
    name="Support knowledge base",
    description="Indexed support manuals and help center docs",
    file_ids=[result.id],
    expires_after={"anchor": "last_active_at", "days": 30},
    x_on_behalf_of="<end-user-id>",
)

const second = await mka1.llm.files.upload({
  xOnBehalfOf: '<end-user-id>',
  requestBody: { file: Bun.file('./help-center-faq.pdf'), purpose: 'assistants' },
});

const vsFile = await mka1.llm.vectorStores.createFile({
  vectorStoreId: vectorStore.id,
  xOnBehalfOf: '<end-user-id>',
  createVectorStoreFileRequest: {
    fileId: second.id,
    attributes: { category: 'faq', version: '2.0' },
  },
});

with open("help-center-faq.pdf", "rb") as fh:
    second = sdk.llm.files.upload(
        file={"file_name": "help-center-faq.pdf", "content": fh.read()},
        purpose="assistants",
        x_on_behalf_of="<end-user-id>",
    )

vs_file = sdk.llm.vector_stores.create_file(
    vector_store_id=vector_store.id,
    file_id=second.id,
    attributes={"category": "faq", "version": "2.0"},
    x_on_behalf_of="<end-user-id>",
)

const results = await mka1.llm.vectorStores.search({
  vectorStoreId: vectorStore.id,
  xOnBehalfOf: '<end-user-id>',
  searchVectorStoreRequest: {
    query: 'How do I reset my password?',
    maxNumResults: 5,
  },
});

results = sdk.llm.vector_stores.search(
    vector_store_id=vector_store.id,
    query="How do I reset my password?",
    max_num_results=5,
    x_on_behalf_of="<end-user-id>",
)

const schema = {
  type: 'object',
  properties: {
    document_title: { type: 'string' },
    reset_link_expiry_minutes: { type: 'number' },
    support_email: { type: 'string' },
  },
  required: ['document_title'],
};

// One-off extraction — schema is a JSON string here
const res = await mka1.llm.extract.extract({
  requestBody: {
    model: 'openai:gpt-4.1', // 'auto' currently 500s on this endpoint
    prompt: 'Extract the document title, reset link expiry, and support email.',
    schema: JSON.stringify(schema),
    file: Bun.file('./support-manual.txt'),
  },
});
// → { success, data: {…}, metadata: {…} }

import json

schema = {
    "type": "object",
    "properties": {
        "document_title": {"type": "string"},
        "reset_link_expiry_minutes": {"type": "number"},
        "support_email": {"type": "string"},
    },
    "required": ["document_title"],
}

# One-off extraction — schema is a JSON string here
with open("support-manual.txt", "rb") as fh:
    res = sdk.llm.extract.extract(
        model="openai:gpt-4.1",  # 'auto' currently 500s on this endpoint
        prompt="Extract the document title, reset link expiry, and support email.",
        schema=json.dumps(schema),
        file={"file_name": "support-manual.txt", "content": fh.read()},
    )
# res.success, res.data, res.metadata

// Reusable template — schema is an object here; the id arrives under data.id
const created = await mka1.llm.extract.createSchema({
  extractionSchema: {
    name: 'support-manual',
    description: 'Extract support manual facts',
    schema,
  },
});

const out = await mka1.llm.extract.extractWithSchema({
  schemaId: created.data.id,
  requestBody: {
    model: 'openai:gpt-4.1',
    prompt: 'Extract the fields.',
    file: Bun.file('./support-manual.txt'),
  },
});

# Reusable template — schema is a dict here; the id arrives under data.id
created = sdk.llm.extract.create_schema(
    name="support-manual",
    description="Extract support manual facts",
    schema=schema,
)

out = sdk.llm.extract.extract_with_schema(
    schema_id=created.data.id,
    model="openai:gpt-4.1",
    prompt="Extract the fields.",
    file={"file_name": "support-manual.txt", "content": open("support-manual.txt", "rb").read()},
)

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' });

const agent = await mka1.agents.createAgent({
  createAgentRequest: {
    name: 'release-research-agent',
    description: 'Looks up current release information before answering.',
    model: 'auto',
    instructions: 'Use web search when the question depends on current external information.',
    tools: [{ type: 'web_search', searchContextSize: 'medium' }],
    metadata: { team: 'docs' },
  },
});
console.log(agent.id);

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

agent = sdk.agents.create_agent(
    name="release-research-agent",
    description="Looks up current release information before answering.",
    model="auto",
    instructions="Use web search when the question depends on current external information.",
    tools=[{"type": "web_search", "search_context_size": "medium"}],
    metadata={"team": "docs"},
)

print(agent.id)

const run = await mka1.agentRuns.createAgentRun({
  agentId: agent.id,
  createAgentRunRequest: {
    input: "What is Bun's current stable version? Use web search before answering.",
    metadata: { request_source: 'docs' },
  },
});

console.log(run.gatewayResponseId);
console.log(run.status);

run = sdk.agent_runs.create_agent_run(
    agent_id="agt_123",
    input="What is Bun's current stable version? Use web search before answering.",
    metadata={"request_source": "docs"},
)

print(run.gateway_response_id)
print(run.status)

const agents = await mka1.agents.listAgents({});
const runs = await mka1.agentRuns.listAgentRuns({ agentId: agent.id });

agents = sdk.agents.list_agents()
runs = sdk.agent_runs.list_agent_runs(agent_id="agt_123")

// Update the agent — this commits version 2
await mka1.agents.updateAgent({
  agentId: agent.id,
  updateAgentRequest: { instructions: 'Answer in exhaustive detail.' },
});

// Inspect the history
const versions = await mka1.agentVersions.listAgentVersions({ agentId: agent.id });
// versions.data → [ { version: 2, isCurrent: true, … }, { version: 1, … } ]

// Fetch one version in full
const v2 = await mka1.agentVersions.getAgentVersion({ agentId: agent.id, version: 2 });

// Roll back to v1 — appends v3 with restoredFromVersion: 1
await mka1.agentVersions.rollbackAgentVersion({ agentId: agent.id, version: 1 });

sdk.agents.update_agent(agent_id=agent.id, instructions="Answer in exhaustive detail.")

versions = sdk.agent_versions.list_agent_versions(agent_id=agent.id)
# versions.data → [AgentVersion(version=2, is_current=True, …), AgentVersion(version=1, …)]

v2 = sdk.agent_versions.get_agent_version(agent_id=agent.id, version=2)

sdk.agent_versions.rollback_agent_version(agent_id=agent.id, version=1)
# history is now v3 (current, restored_from_version=1), v2, v1

import type { ResponseObject } from '@meetkai/mka1/models/components';

const response = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'auto',
    instructions: 'Use Linear tools when the user asks about tasks, bugs, or projects.',
    input: 'List my most recent Linear issue assigned to me.',
    tools: [
      {
        type: 'mcp',
        serverLabel: 'Linear MCP',
        serverUrl: 'https://mcp.linear.app/mcp',
        allowedTools: ['issues.list'],
        headers: { Authorization: `Bearer ${process.env.LINEAR_API_KEY}` },
        requireApproval: 'never',
      },
    ],
  },
}) as ResponseObject;

console.log(response.outputText);

import os

response = sdk.llm.responses.create(
    model="auto",
    instructions="Use Linear tools when the user asks about tasks, bugs, or projects.",
    input="List my most recent Linear issue assigned to me.",
    tools=[
        {
            "type": "mcp",
            "server_label": "Linear MCP",
            "server_url": "https://mcp.linear.app/mcp",
            "allowed_tools": ["issues.list"],
            "headers": {"Authorization": f"Bearer {os.environ['LINEAR_API_KEY']}"},
            "require_approval": "never",
        },
    ],
)

print(response.output_text)

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({ bearerAuth: `Bearer ${YOUR_API_KEY}` });

const prompt = await mka1.llm.prompts.create({
  createPromptRequest: {
    name: 'greeting',
    template: 'Hello, {{name}}! Welcome to {{company}}.',
  },
});

const rendered = await mka1.llm.prompts.get({
  id: prompt.id,
  variables: JSON.stringify({ name: 'Alice', company: 'Acme' }),
});
console.log(rendered.renderedTemplate); // "Hello, Alice! Welcome to Acme."

import json

prompt = sdk.llm.prompts.create(
    name="greeting",
    template="Hello, {{name}}! Welcome to {{company}}.",
)

rendered = sdk.llm.prompts.get(
    id=prompt.id,
    variables=json.dumps({"name": "Alice", "company": "Acme"}),
)
print(rendered.rendered_template)  # "Hello, Alice! Welcome to Acme."

import { SDK } from '@meetkai/mka1';
import { writeFileSync } from 'node:fs';

const mka1 = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

const { headers, result } = await mka1.llm.speech.speak({
  textToSpeechRequest: {
    text: 'Welcome to the MKA1 API speech guide.',
    language: 'en',
  },
});
// headers['x-language-code'] → ['en']

const chunks = [];
for await (const chunk of result) chunks.push(chunk);
writeFileSync('speech.wav', Buffer.concat(chunks));

res = sdk.llm.speech.speak(
    text="Welcome to the MKA1 API speech guide.",
    language="en",
)
# res.headers["x-language-code"] → ["en"]; res.result streams the WAV bytes

with open("speech.wav", "wb") as fh:
    fh.write(res.result.read())

// Low-latency variant
const streamed = await mka1.llm.speech.speakStreaming({
  textToSpeechStreamingRequest: {
    text: 'Start speaking this response as soon as audio is ready.',
    language: 'en',
    format: 'mp3',
  },
});

# Low-latency variant — note format_ with a trailing underscore
streamed = sdk.llm.speech.speak_streaming(
    text="Start speaking this response as soon as audio is ready.",
    language="en",
    format_="mp3",
)

import { openAsBlob } from 'node:fs';

const result = await mka1.llm.speech.transcribe({
  language: 'en',
  prompt: 'This is a technical podcast about machine learning.',
  temperature: 0.2,
  requestBody: { file: await openAsBlob('episode.wav') },
});

console.log(result.text);       // transcript
console.log(result.confidence); // detection confidence

with open("episode.wav", "rb") as fh:
    result = sdk.llm.speech.transcribe(
        file={"file_name": "episode.wav", "content": fh.read()},
        language="en",
        prompt="This is a technical podcast about machine learning.",
        temperature=0.2,
    )

print(result.text)        # transcript
print(result.confidence)  # detection confidence

const now = Math.floor(Date.now() / 1000);

const spend = await mka1.usage.costs({
  startTime: now - 7 * 24 * 60 * 60, // last 7 days (unix seconds)
  endTime: now,
  groupBy: 'model,api_key_id', // comma-separated dimensions
});
// spend.data → [{ model, apiKeyId, teamId, externalUserId, orgId, cost }, …]

import time

now = int(time.time())
spend = sdk.usage.costs(
    start_time=now - 7 * 24 * 3600,  # last 7 days (unix seconds)
    end_time=now,
    group_by="model,api_key_id",  # comma-separated dimensions
)
# spend.data → rows with model, api_key_id, team_id, external_user_id, org_id, cost

// Monthly self-budget on an API key: warn at 80%, block at 100%
await mka1.budgets.setApiKey({
  apiKeyId: 'ak_…',
  requestBody: {
    period: 'monthly',
    limit: 250, // in your cluster currency — see budgets.getCurrency()
    thresholds: [
      { pct: 80, action: 'alert' },
      { pct: 100, action: 'block' },
    ],
    webhookUrl: 'https://your-app.example.com/hooks/budget',
    webhookSecret: process.env.MKA1_WEBHOOK_SECRET,
  },
});

const budgets = await mka1.budgets.getApiKey({ apiKeyId: 'ak_…' });
const events = await mka1.budgets.apiKeyEvents({ apiKeyId: 'ak_…' });
await mka1.budgets.deleteApiKey({ apiKeyId: 'ak_…', owner: 'org' });

// Org-level variants: budgets.setOrg / getOrg / deleteOrg / orgEvents ({ orgId, … })

sdk.budgets.set_api_key(
    api_key_id="ak_…",
    period="monthly",
    limit=250,
    thresholds=[
        {"pct": 80, "action": "alert"},
        {"pct": 100, "action": "block"},
    ],
)

budgets = sdk.budgets.get_api_key(api_key_id="ak_…")
events = sdk.budgets.api_key_events(api_key_id="ak_…")
sdk.budgets.delete_api_key(api_key_id="ak_…", owner="org")

# Org-level variants: set_org / get_org / delete_org / org_events (org_id=…)

const now = Math.floor(Date.now() / 1000);

const usage = await mka1.llm.usage.responses({
  startTime: now - 7 * 24 * 60 * 60, // last 7 days (unix seconds)
  endTime: now,
  bucketWidth: '1d',
  groupBy: 'model',
});
// usage.data → one bucket per day, each with per-model results
// (input/output tokens, request counts)

import time

now = int(time.time())
usage = sdk.llm.usage.responses(
    start_time=now - 7 * 24 * 3600,  # last 7 days (unix seconds)
    end_time=now,
    bucket_width="1d",
    group_by="model",
)
# usage.data → one bucket per day, each with per-model results

// 1. Register the model to serve (pin a revision for reproducible deploys)
await mka1.serving.models.register({
  modelRegister: { name: 'qwen-7b', source: 'Qwen/Qwen2.5-7B-Instruct' },
});

// 2. Deploy it behind an autoscaling endpoint
const deployment = await mka1.serving.deployments.create({
  deploymentCreate: {
    name: 'qwen-7b-prod',
    model: 'qwen-7b',
    engine: 'vllm',
    accelerator: { type: 'H100', count: 1, fallback: ['A100'] },
    scaling: { minContainers: 1, maxContainers: 4, maxConcurrentInputs: 32 },
    engineArgs: ['--max-model-len', '8192'],
    endpointAuth: true,
  },
});
// the endpoint URL appears on the deployment once it's ready

// 3. Operate it
await mka1.serving.deployments.updateScaling({
  deploymentId: deployment.id,
  scaling: { minContainers: 2, maxContainers: 8 }, // applies in place — no new revision
});

const logs = await mka1.serving.deployments.getLogs({ deploymentId: deployment.id, tail: 100 });

await mka1.serving.deployments.rollback({
  deploymentId: deployment.id,
  deploymentRollbackRequest: { revision: 1 }, // config changes roll revisions
});

# 1. Register the model to serve (pin a revision for reproducible deploys)
sdk.serving.models.register(name="qwen-7b", source="Qwen/Qwen2.5-7B-Instruct")

# 2. Deploy it behind an autoscaling endpoint
deployment = sdk.serving.deployments.create(
    name="qwen-7b-prod",
    model="qwen-7b",
    engine="vllm",
    accelerator={"type": "H100", "count": 1, "fallback": ["A100"]},
    scaling={"min_containers": 1, "max_containers": 4, "max_concurrent_inputs": 32},
    engine_args=["--max-model-len", "8192"],
    endpoint_auth=True,
)
# the endpoint URL appears on the deployment once it's ready

# 3. Operate it
sdk.serving.deployments.update_scaling(
    deployment_id=deployment.id,
    min_containers=2,
    max_containers=8,  # applies in place — no new revision
)

logs = sdk.serving.deployments.get_logs(deployment_id=deployment.id, tail=100)

sdk.serving.deployments.rollback(deployment_id=deployment.id, revision=1)