Guía de primeros pasos de la plataforma MKA1

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

const result = await mka1.llm.responses.create({
  xOnBehalfOf: 'user_123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Resuma este ticket de soporte.',
  },
}) as ResponseObject;
console.log(result.outputText);

response = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Resuma este ticket de soporte.",
    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>" } — luego envíe Authorization: Bearer <jwt>

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

// jwt.token es el JWT de corta duración — úselo como 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 es el JWT de corta duración — úselo como bearer
as_end_user = SDK(bearer_auth=f"Bearer {jwt.token}")

mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --input '"¿Cuál es la capital de Francia?"' \
  -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: 'meetkai:functionary-es-mini',
    input: '¿Cuál es la capital de Francia?',
  },
}) 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="meetkai:functionary-es-mini",
    input="¿Cuál es la capital de Francia?",
)

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data '{ "model": "meetkai:functionary-es-mini", "input": "¿Cuál es la capital de Francia?" }'

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: 'meetkai:functionary-es-mini',
    input: 'Escriba un resumen de una frase de la API de MKA1.',
  },
});

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

res = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Escriba un resumen de una frase de la API de MKA1.",
    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: 'meetkai:functionary-es-mini',
    input: 'Escriba tres viñetas de notas de versión para nuestra actualización de docs.',
    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="meetkai:functionary-es-mini",
    input="Escriba tres viñetas de notas de versión para nuestra actualización de docs.",
    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', // con visión — 'auto' descarta imágenes hoy
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Describa lo que ve en esta imagen.' },
          {
            type: 'input_image',
            imageUrl: 'https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg',
          },
        ],
      },
    ],
  },
});

res = sdk.llm.responses.create(
    model="openai:gpt-4.1",  # con visión — 'auto' descarta imágenes hoy
    input=[
        {
            "type": "message",
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describa lo que ve en esta imagen."},
                {
                    "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: 'meetkai:functionary-es-mini',
    input: 'Escriba una historia del fax en dos frases.',
    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="meetkai:functionary-es-mini",
    input="Escriba una historia del fax en dos frases.",
    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: 'meetkai:functionary-es-mini',
    input: 'Resuma este informe de 80 páginas…',
    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="meetkai:functionary-es-mini",
    input="Resuma este informe de 80 páginas…",
    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. Cree una conversación (metadatos opcionales para su propio enrutamiento)
const conv = await mka1.llm.conversations.create({
  xOnBehalfOf: '<end-user-id>',
  createConversationRequest: {
    metadata: { session_id: 'web-42', channel: 'support' },
  },
});

// 2. (Opcional) escriba historial explícitamente antes de llamar a Responses
await mka1.llm.conversations.createItems({
  conversationId: conv.id,
  xOnBehalfOf: '<end-user-id>',
  createItemsRequest: {
    items: [
      { type: 'message', role: 'user', content: 'Resuma el último ticket de soporte.' },
    ],
  },
});

// 3. Continúe el flujo — adjunte la conversación para que el modelo tenga historial
const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    conversation: conv.id,
    input: 'Convierta ese resumen en una respuesta lista para el cliente.',
  },
});

# 1. Cree una conversación (metadatos opcionales para su propio enrutamiento)
conv = sdk.llm.conversations.create(
    metadata={"session_id": "web-42", "channel": "support"},
    x_on_behalf_of="<end-user-id>",
)

# 2. (Opcional) escriba historial explícitamente antes de llamar a Responses
sdk.llm.conversations.create_items(
    conversation_id=conv.id,
    items=[
        {"type": "message", "role": "user", "content": "Resuma el último ticket de soporte."},
    ],
    x_on_behalf_of="<end-user-id>",
)

# 3. Continúe el flujo — adjunte la conversación para que el modelo tenga historial
result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    conversation=conv.id,
    input="Convierta ese resumen en una respuesta lista para el cliente.",
)

// Sesión 1: guarde un dato
await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Recuerda esto: mi color favorito es azul.',
    tools: [{ type: 'history' }],
    store: true,
  },
});

// Sesión 2 (minutos o días después — la indexación tarda ~1–2 min): recupérelo
const recalled = await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: '¿Cuál es mi color favorito?',
    tools: [{ type: 'history' }],
    store: true,
  },
});
// → "Tu color favorito es azul."

# Sesión 1: guarde un dato
sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Recuerda esto: mi color favorito es azul.",
    tools=[{"type": "history"}],
    store=True,
    x_on_behalf_of="user-123",
)

# Sesión 2 (minutos o días después — la indexación tarda ~1–2 min): recupérelo
recalled = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="¿Cuál es mi color favorito?",
    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 → p. ej. 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 → p. ej. file_1783481291595_r19s7ueog7o

const vectorStore = await mka1.llm.vectorStores.create({
  xOnBehalfOf: '<end-user-id>',
  createVectorStoreRequest: {
    name: 'Base de conocimiento de soporte',
    description: 'Manuales de soporte y documentos del centro de ayuda indexados',
    fileIds: [result.id],
    expiresAfter: { anchor: 'last_active_at', days: 30 },
  },
});

vector_store = sdk.llm.vector_stores.create(
    name="Base de conocimiento de soporte",
    description="Manuales de soporte y documentos del centro de ayuda indexados",
    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: '¿Cómo restablezco mi contraseña?',
    maxNumResults: 5,
  },
});

results = sdk.llm.vector_stores.search(
    vector_store_id=vector_store.id,
    query="¿Cómo restablezco mi contraseña?",
    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'],
};

// Extracción puntual — aquí el esquema es una cadena JSON
const res = await mka1.llm.extract.extract({
  requestBody: {
    model: 'openai:gpt-4.1', // 'auto' actualmente devuelve 500 en este endpoint
    prompt: 'Extraiga el título del documento, la caducidad del enlace de restablecimiento y el correo de soporte.',
    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"],
}

# Extracción puntual — aquí el esquema es una cadena JSON
with open("support-manual.txt", "rb") as fh:
    res = sdk.llm.extract.extract(
        model="openai:gpt-4.1",  # 'auto' actualmente devuelve 500 en este endpoint
        prompt="Extraiga el título del documento, la caducidad del enlace de restablecimiento y el correo de soporte.",
        schema=json.dumps(schema),
        file={"file_name": "support-manual.txt", "content": fh.read()},
    )
# res.success, res.data, res.metadata

// Plantilla reutilizable — aquí el esquema es un objeto; el id llega bajo data.id
const created = await mka1.llm.extract.createSchema({
  extractionSchema: {
    name: 'support-manual',
    description: 'Extraer datos del manual de soporte',
    schema,
  },
});

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

# Plantilla reutilizable — aquí el esquema es un dict; el id llega bajo data.id
created = sdk.llm.extract.create_schema(
    name="support-manual",
    description="Extraer datos del manual de soporte",
    schema=schema,
)

out = sdk.llm.extract.extract_with_schema(
    schema_id=created.data.id,
    model="openai:gpt-4.1",
    prompt="Extraiga los campos.",
    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: 'Busca información actual de versiones antes de responder.',
    model: 'meetkai:functionary-es-mini',
    instructions: 'Use la búsqueda web cuando la pregunta dependa de información externa actual.',
    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="Busca información actual de versiones antes de responder.",
    model="meetkai:functionary-es-mini",
    instructions="Use la búsqueda web cuando la pregunta dependa de información externa actual.",
    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: '¿Cuál es la versión estable actual de Bun? Use la búsqueda web antes de responder.',
    metadata: { request_source: 'docs' },
  },
});

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

run = sdk.agent_runs.create_agent_run(
    agent_id="agt_123",
    input="¿Cuál es la versión estable actual de Bun? Use la búsqueda web antes de responder.",
    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")

// Actualice el agente — esto confirma la versión 2
await mka1.agents.updateAgent({
  agentId: agent.id,
  updateAgentRequest: { instructions: 'Responda con detalle exhaustivo.' },
});

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

// Obtenga una versión completa
const v2 = await mka1.agentVersions.getAgentVersion({ agentId: agent.id, version: 2 });

// Revierta a v1 — añade v3 con restoredFromVersion: 1
await mka1.agentVersions.rollbackAgentVersion({ agentId: agent.id, version: 1 });

sdk.agents.update_agent(agent_id=agent.id, instructions="Responda con detalle exhaustivo.")

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)
# el historial ahora es v3 (actual, restored_from_version=1), v2, v1

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

const response = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    instructions: 'Use las herramientas de Linear cuando el usuario pregunte sobre tareas, errores o proyectos.',
    input: 'Liste mi issue de Linear más reciente asignado a mí.',
    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="meetkai:functionary-es-mini",
    instructions="Use las herramientas de Linear cuando el usuario pregunte sobre tareas, errores o proyectos.",
    input="Liste mi issue de Linear más reciente asignado a mí.",
    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: '¡Hola, {{name}}! Bienvenido a {{company}}.',
  },
});

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

import json

prompt = sdk.llm.prompts.create(
    name="greeting",
    template="¡Hola, {{name}}! Bienvenido a {{company}}.",
)

rendered = sdk.llm.prompts.get(
    id=prompt.id,
    variables=json.dumps({"name": "Alice", "company": "Acme"}),
)
print(rendered.rendered_template)  # "¡Hola, Alice! Bienvenido a 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 transmite los bytes WAV

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

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

# Variante de baja latencia — note format_ con guion bajo final
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);       // transcripción
console.log(result.confidence); // confianza de la detección

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)        # transcripción
print(result.confidence)  # confianza de la detección

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

const spend = await mka1.usage.costs({
  startTime: now - 7 * 24 * 60 * 60, // últimos 7 días (segundos unix)
  endTime: now,
  groupBy: 'model,api_key_id', // dimensiones separadas por comas
});
// spend.data → [{ model, apiKeyId, teamId, externalUserId, orgId, cost }, …]

import time

now = int(time.time())
spend = sdk.usage.costs(
    start_time=now - 7 * 24 * 3600,  # últimos 7 días (segundos unix)
    end_time=now,
    group_by="model,api_key_id",  # dimensiones separadas por comas
)
# spend.data → filas con model, api_key_id, team_id, external_user_id, org_id, cost

// Presupuesto mensual propio en una clave API: advertir al 80%, bloquear al 100%
await mka1.budgets.setApiKey({
  apiKeyId: 'ak_…',
  requestBody: {
    period: 'monthly',
    limit: 250, // en la moneda de su clúster — vea 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' });

// Variantes a nivel de org: 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")

# Variantes a nivel de org: 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, // últimos 7 días (segundos unix)
  endTime: now,
  bucketWidth: '1d',
  groupBy: 'model',
});
// usage.data → un bucket por día, cada uno con resultados por modelo
// (tokens de entrada/salida, conteos de solicitudes)

import time

now = int(time.time())
usage = sdk.llm.usage.responses(
    start_time=now - 7 * 24 * 3600,  # últimos 7 días (segundos unix)
    end_time=now,
    bucket_width="1d",
    group_by="model",
)
# usage.data → un bucket por día, cada uno con resultados por modelo

// 1. Registre el modelo a servir (fije una revisión para despliegues reproducibles)
await mka1.serving.models.register({
  modelRegister: { name: 'qwen-7b', source: 'Qwen/Qwen2.5-7B-Instruct' },
});

// 2. Despliéguelo tras un endpoint con autoescalado
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,
  },
});
// la URL del endpoint aparece en el despliegue cuando está listo

// 3. Opérelo
await mka1.serving.deployments.updateScaling({
  deploymentId: deployment.id,
  scaling: { minContainers: 2, maxContainers: 8 }, // se aplica en el sitio — sin nueva revisión
});

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

await mka1.serving.deployments.rollback({
  deploymentId: deployment.id,
  deploymentRollbackRequest: { revision: 1 }, // los cambios de configuración generan revisiones
});

# 1. Registre el modelo a servir (fije una revisión para despliegues reproducibles)
sdk.serving.models.register(name="qwen-7b", source="Qwen/Qwen2.5-7B-Instruct")

# 2. Despliéguelo tras un endpoint con autoescalado
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,
)
# la URL del endpoint aparece en el despliegue cuando está listo

# 3. Opérelo
sdk.serving.deployments.update_scaling(
    deployment_id=deployment.id,
    min_containers=2,
    max_containers=8,  # se aplica en el sitio — sin nueva revisión
)

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

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