> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mka1.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Repositório de Prompts

> Gerencie modelos de prompt versionados com histórico de alterações, reversão e renderização de variáveis através da API de Prompts.

A API de Prompts permite que você armazene, versiona e gerencie modelos de prompt de forma centralizada.
Cada alteração em um modelo cria uma versão imutável, fornecendo um histórico completo de mudanças
com a possibilidade de reverter para qualquer versão anterior a qualquer momento.

Os modelos suportam marcadores `{{variable}}` que são renderizados no servidor quando você
recupera um prompt, permitindo reutilizar o mesmo modelo em diferentes contextos.

## Criar um prompt

Crie um prompt com um nome e modelo. A primeira versão é criada automaticamente.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts create \
    --body '{
      "name": "greeting",
      "description": "Um modelo simples de saudação",
      "template": "Hello, {{name}}! Welcome to {{company}}.",
      "metadata": { "team": "onboarding" }
    }' \
    -H 'X-On-Behalf-Of: <end-user-id>'
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1';

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

  const result = await mka1.llm.prompts.create({
    name: 'greeting',
    description: 'Um modelo simples de saudação',
    template: 'Hello, {{name}}! Welcome to {{company}}.',
    metadata: { team: 'onboarding' },
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

  console.log(result.id);            // prompt_abc123...
  console.log(result.activeVersion); // 1
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var result = await sdk.Llm.Prompts.CreateAsync(
      new CreatePromptRequest
      {
          Name = "greeting",
          Description = "Um modelo simples de saudação",
          Template = "Hello, {{name}}! Welcome to {{company}}.",
          Metadata = new Dictionary<string, object> { { "team", "onboarding" } },
      }
  );

  Console.WriteLine(result.CreatePromptResponseValue!.Id);            // prompt_abc123...
  Console.WriteLine(result.CreatePromptResponseValue!.ActiveVersion); // 1
  ```

  ```python Python SDK theme={null}
  from mka1 import SDK

  sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

  result = sdk.llm.prompts.create(
      name="greeting",
      description="Um modelo simples de saudação",
      template="Hello, {{name}}! Welcome to {{company}}.",
      metadata={"team": "onboarding"},
  )

  print(result.id)              # prompt_abc123...
  print(result.active_version)  # 1
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/prompts \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "name": "greeting",
      "description": "Um modelo simples de saudação",
      "template": "Hello, {{name}}! Welcome to {{company}}.",
      "metadata": { "team": "onboarding" }
    }'
  ```
</CodeGroup>

## Recuperar um prompt com variáveis renderizadas

Passe `variables` como parâmetro de consulta para renderizar o modelo com seus valores.
Marcadores não correspondentes permanecem inalterados.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts get \
    --id prompt_abc123 \
    --variables '{"name":"Alice","company":"Acme"}'
  ```

  ```ts MKA1 SDK theme={null}
  const prompt = await mka1.llm.prompts.get({
    id: promptId,
    variables: JSON.stringify({ name: 'Alice', company: 'Acme' }),
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

  console.log(prompt.renderedTemplate);
  // "Hello, Alice! Welcome to Acme."
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var prompt = await sdk.Llm.Prompts.GetAsync(
      id: promptId,
      variables: "{\"name\":\"Alice\",\"company\":\"Acme\"}"
  );

  Console.WriteLine(prompt.GetPromptResponseValue!.RenderedTemplate);
  // "Hello, Alice! Welcome to Acme."
  ```

  ```python Python SDK theme={null}
  prompt = sdk.llm.prompts.get(
      id=prompt_id,
      variables='{"name": "Alice", "company": "Acme"}',
  )

  print(prompt.rendered_template)
  # "Hello, Alice! Welcome to Acme."
  ```

  ```bash bash theme={null}
  # Codifique o JSON das variáveis na URL
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123?variables=%7B%22name%22%3A%22Alice%22%2C%22company%22%3A%22Acme%22%7D" \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>'
  ```
</CodeGroup>

## Listar prompts

Recupere uma lista paginada de todos os prompts. Use `after` para paginação baseada em cursor.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts list --limit 10 --order desc
  ```

  ```ts MKA1 SDK theme={null}
  const list = await mka1.llm.prompts.list({
    limit: 10,
    order: 'desc',
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

  for (const prompt of list.data) {
    console.log(prompt.name, `v${prompt.activeVersion}`);
  }

  if (list.hasMore) {
    // Buscar próxima página usando o último ID como cursor
    const next = await mka1.llm.prompts.list({
      limit: 10,
      after: list.lastId,
    }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });
  }
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var prompts = await sdk.Llm.Prompts.ListAsync();

  Console.WriteLine(prompts);
  ```

  ```python Python SDK theme={null}
  prompts = sdk.llm.prompts.list()

  for prompt in prompts.data:
      print(prompt.name, f"v{prompt.active_version}")
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts?limit=10&order=desc" \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>'
  ```
</CodeGroup>

## Atualizar metadados do prompt

Atualize o nome, descrição ou metadados de um prompt. Para alterar o modelo,
crie uma nova versão.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts update \
    --id prompt_abc123 \
    --body '{
      "name": "welcome-greeting",
      "description": "Saudação atualizada para o fluxo de boas-vindas",
      "metadata": { "team": "onboarding", "reviewed": true }
    }'
  ```

  ```ts MKA1 SDK theme={null}
  const updated = await mka1.llm.prompts.update({
    id: promptId,
    requestBody: {
      name: 'welcome-greeting',
      description: 'Saudação atualizada para o fluxo de boas-vindas',
      metadata: { team: 'onboarding', reviewed: true },
    },
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var updated = await sdk.Llm.Prompts.UpdateAsync(
      id: promptId,
      body: new UpdatePromptRequestBody
      {
          Name = "welcome-greeting",
          Description = "Saudação atualizada para o fluxo de boas-vindas",
          Metadata = new Dictionary<string, object>
          {
              { "team", "onboarding" },
              { "reviewed", true },
          },
      }
  );
  ```

  ```python Python SDK theme={null}
  updated = sdk.llm.prompts.update(
      id=prompt_id,
      name="welcome-greeting",
      description="Saudação atualizada para o fluxo de boas-vindas",
      metadata={"team": "onboarding", "reviewed": True},
  )
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123" \
    --request PUT \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "name": "welcome-greeting",
      "description": "Saudação atualizada para o fluxo de boas-vindas",
      "metadata": { "team": "onboarding", "reviewed": true }
    }'
  ```
</CodeGroup>

## Criar uma nova versão

Cada alteração no modelo cria uma nova versão. A nova versão se torna automaticamente a versão ativa.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts create-version \
    --id prompt_abc123 \
    --body '{
      "template": "Hi {{name}}! Welcome aboard at {{company}}. Your onboarding starts {{date}}."
    }'
  ```

  ```ts MKA1 SDK theme={null}
  const version = await mka1.llm.prompts.createVersion({
    id: promptId,
    requestBody: {
      template: 'Hi {{name}}! Welcome aboard at {{company}}. Your onboarding starts {{date}}.',
    },
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

  console.log(version.version);  // 2
  console.log(version.template); // O novo texto do modelo
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var version = await sdk.Llm.Prompts.CreateVersionAsync(
      id: promptId,
      body: new CreatePromptVersionRequestBody
      {
          Template = "Hi {{name}}! Welcome aboard at {{company}}. Your onboarding starts {{date}}.",
      }
  );

  Console.WriteLine(version.CreateVersionResponse!.Version);  // 2
  Console.WriteLine(version.CreateVersionResponse!.Template); // O novo texto do modelo
  ```

  ```python Python SDK theme={null}
  version = sdk.llm.prompts.create_version(
      id=prompt_id,
      template="Hi {{name}}! Welcome aboard at {{company}}. Your onboarding starts {{date}}.",
  )

  print(version.version)   # 2
  print(version.template)  # O novo texto do modelo
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/versions" \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "template": "Hi {{name}}! Welcome aboard at {{company}}. Your onboarding starts {{date}}."
    }'
  ```
</CodeGroup>

## Visualizar histórico de versões

Liste todas as versões de um prompt para ver seu histórico completo de alterações.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts list-versions --id prompt_abc123 --order desc
  ```

  ```ts MKA1 SDK theme={null}
  const versions = await mka1.llm.prompts.listVersions({
    id: promptId,
    order: 'desc',
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

  for (const v of versions.data) {
    console.log(`v${v.version}: ${v.template.slice(0, 50)}...`);
  }
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var versions = await sdk.Llm.Prompts.ListVersionsAsync(
      id: promptId,
      order: ListPromptVersionsOrder.Desc
  );

  foreach (var v in versions.ListVersionsResponse!.Data)
  {
      Console.WriteLine($"v{v.Version}: {v.Template.Substring(0, 50)}...");
  }
  ```

  ```python Python SDK theme={null}
  versions = sdk.llm.prompts.list_versions(id=prompt_id)

  for v in versions.data:
      print(f"v{v.version}: {v.template[:50]}...")
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/versions?order=desc" \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>'
  ```
</CodeGroup>

## Recuperar uma versão específica

Busque uma versão única pelo seu número de versão.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts get-version --id prompt_abc123 --version-param 1
  ```

  ```ts MKA1 SDK theme={null}
  const v1 = await mka1.llm.prompts.getVersion({
    id: promptId,
    version: 1,
  }, {
    headers: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  console.log(v1.template);
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var v1 = await sdk.Llm.Prompts.GetVersionAsync(
      id: promptId,
      version: 1
  );

  Console.WriteLine(v1.CreateVersionResponse!.Template);
  ```

  ```python Python SDK theme={null}
  v1 = sdk.llm.prompts.get_version(id=prompt_id, version=1)

  print(v1.template)
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/versions/1" \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>'
  ```
</CodeGroup>

## Reverter para uma versão anterior

A reversão define uma versão anterior como a versão ativa. Todas as versões são preservadas — a reversão
não exclui versões mais recentes, então você sempre pode avançar novamente.

<CodeGroup>
  ```bash CLI theme={null}
  # Atualmente na versão 2, reverter para a versão 1
  mka1 llm prompts rollback --id prompt_abc123 --version-param 1
  ```

  ```ts MKA1 SDK theme={null}
  // Atualmente na versão 2, reverter para a versão 1
  const rolledBack = await mka1.llm.prompts.rollback({
    id: promptId,
    requestBody: {
      version: 1,
    },
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

  console.log(rolledBack.activeVersion);  // 1
  console.log(rolledBack.latestVersion);  // 2 (ainda existe)
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  // Atualmente na versão 2, reverter para a versão 1
  var rolledBack = await sdk.Llm.Prompts.RollbackAsync(
      id: promptId,
      body: new RollbackPromptRequestBody { Version = 1 }
  );

  Console.WriteLine(rolledBack.UpdatePromptResponse!.ActiveVersion);  // 1
  Console.WriteLine(rolledBack.UpdatePromptResponse!.LatestVersion);  // 2 (ainda existe)
  ```

  ```python Python SDK theme={null}
  # Atualmente na versão 2, reverter para a versão 1
  rolled_back = sdk.llm.prompts.rollback(id=prompt_id, version=1)

  print(rolled_back.active_version)  # 1
  print(rolled_back.latest_version)  # 2 (ainda existe)
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/rollback" \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{ "version": 1 }'
  ```
</CodeGroup>

## Excluir um prompt

Excluir um prompt o remove permanentemente, junto com todas as suas versões.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts delete --id prompt_abc123
  ```

  ```ts MKA1 SDK theme={null}
  const deleted = await mka1.llm.prompts.delete({
    id: promptId,
  }, {
    headers: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  console.log(deleted.deleted); // true
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  var deleted = await sdk.Llm.Prompts.DeleteAsync(id: promptId);

  Console.WriteLine(deleted.DeletePromptResponseValue!.Deleted); // True
  ```

  ```python Python SDK theme={null}
  deleted = sdk.llm.prompts.delete(id=prompt_id)

  print(deleted.deleted)  # True
  ```

  ```bash bash theme={null}
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123" \
    --request DELETE \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>'
  ```
</CodeGroup>

## Exemplo completo: fluxo de versionamento e reversão

Este exemplo demonstra o ciclo de vida completo — criação de um prompt, iteração no
modelo, revisão do histórico e reversão.

<CodeGroup>
  ```bash CLI theme={null}
  # 1. Crie um prompt com o modelo inicial
  mka1 llm prompts create \
    --body '{
      "name": "support-reply",
      "template": "Hi {{customer}}, thanks for contacting us about {{issue}}."
    }'
  # → { "id": "prompt_abc123", "active_version": 1, ... }

  # 2. Lance a v2 com um tom mais amigável
  mka1 llm prompts create-version \
    --id prompt_abc123 \
    --body '{
      "template": "Hey {{customer}}! We got your message about {{issue}} and are on it."
    }'

  # 3. Recupere o prompt com variáveis renderizadas
  mka1 llm prompts get \
    --id prompt_abc123 \
    --variables '{"customer":"Alice","issue":"billing"}'

  # 4. Revise o histórico de versões
  mka1 llm prompts list-versions --id prompt_abc123 --order asc

  # 5. Reverter para a v1
  mka1 llm prompts rollback --id prompt_abc123 --version-param 1

  # 6. Limpeza
  mka1 llm prompts delete --id prompt_abc123
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1';

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

  const headers = { 'X-On-Behalf-Of': 'user-123' };

  // 1. Crie um prompt com o modelo inicial
  const prompt = await mka1.llm.prompts.create({
    name: 'support-reply',
    template: 'Hi {{customer}}, thanks for contacting us about {{issue}}.',
  }, { headers });

  console.log('Criado:', prompt.id, 'v1');

  // 2. Lance a v2 com um tom mais amigável
  const v2 = await mka1.llm.prompts.createVersion({
    id: prompt.id,
    requestBody: {
      template: 'Hey {{customer}}! We got your message about {{issue}} and are on it.',
    },
  }, { headers });

  console.log('Criada v2:', v2.version);

  // 3. Recupere o prompt — versão ativa agora é a v2
  const current = await mka1.llm.prompts.get({
    id: prompt.id,
    variables: JSON.stringify({ customer: 'Alice', issue: 'billing' }),
  }, { headers });

  console.log('Ativo:', current.renderedTemplate);
  // "Hey Alice! We got your message about billing and are on it."

  // 4. Revise o histórico de versões
  const history = await mka1.llm.prompts.listVersions({
    id: prompt.id,
    order: 'asc',
  }, { headers });

  for (const v of history.data) {
    console.log(`  v${v.version}: ${v.template}`);
  }

  // 5. Reverter para a v1
  const rolledBack = await mka1.llm.prompts.rollback({
    id: prompt.id,
    requestBody: {
      version: 1,
    },
  }, { headers });

  console.log('Revertido para v' + rolledBack.activeVersion);
  // active_version=1, latest_version=2

  // 6. Limpeza
  await mka1.llm.prompts.delete({ id: prompt.id }, { headers });
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(
      bearerAuth: "Bearer <mka1-api-key>",
      serverUrl: "https://apigw.mka1.com"
  );

  // 1. Crie um prompt com o modelo inicial
  var prompt = await sdk.Llm.Prompts.CreateAsync(
      new CreatePromptRequest
      {
          Name = "support-reply",
          Template = "Hi {{customer}}, thanks for contacting us about {{issue}}.",
      }
  );

  var promptId = prompt.CreatePromptResponseValue!.Id;
  Console.WriteLine($"Criado: {promptId} v1");

  // 2. Lance a v2 com um tom mais amigável
  var v2 = await sdk.Llm.Prompts.CreateVersionAsync(
      id: promptId,
      body: new CreatePromptVersionRequestBody
      {
          Template = "Hey {{customer}}! We got your message about {{issue}} and are on it.",
      }
  );

  Console.WriteLine($"Criada v2: {v2.CreateVersionResponse!.Version}");

  // 3. Recupere o prompt com variáveis renderizadas
  var current = await sdk.Llm.Prompts.GetAsync(
      id: promptId,
      variables: "{\"customer\":\"Alice\",\"issue\":\"billing\"}"
  );

  Console.WriteLine($"Ativo: {current.GetPromptResponseValue!.RenderedTemplate}");

  // 4. Revise o histórico de versões
  var history = await sdk.Llm.Prompts.ListVersionsAsync(
      id: promptId,
      order: ListPromptVersionsOrder.Asc
  );

  foreach (var v in history.ListVersionsResponse!.Data)
  {
      Console.WriteLine($"  v{v.Version}: {v.Template}");
  }

  // 5. Reverter para a v1
  var rolledBack = await sdk.Llm.Prompts.RollbackAsync(
      id: promptId,
      body: new RollbackPromptRequestBody { Version = 1 }
  );

  Console.WriteLine($"Revertido para v{rolledBack.UpdatePromptResponse!.ActiveVersion}");

  // 6. Limpeza
  await sdk.Llm.Prompts.DeleteAsync(id: promptId);
  ```

  ```python Python SDK theme={null}
  from mka1 import SDK

  sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

  # 1. Crie um prompt com o modelo inicial
  prompt = sdk.llm.prompts.create(
      name="support-reply",
      template="Hi {{customer}}, thanks for contacting us about {{issue}}.",
  )

  print("Criado:", prompt.id, "v1")

  # 2. Lance a v2 com um tom mais amigável
  v2 = sdk.llm.prompts.create_version(
      id=prompt.id,
      template="Hey {{customer}}! We got your message about {{issue}} and are on it.",
  )

  print("Criada v2:", v2.version)

  # 3. Recupere o prompt — versão ativa agora é a v2
  current = sdk.llm.prompts.get(
      id=prompt.id,
      variables='{"customer": "Alice", "issue": "billing"}',
  )

  print("Ativo:", current.rendered_template)
  # "Hey Alice! We got your message about billing and are on it."

  # 4. Revise o histórico de versões
  history = sdk.llm.prompts.list_versions(id=prompt.id)

  for v in history.data:
      print(f"  v{v.version}: {v.template}")

  # 5. Reverter para a v1
  rolled_back = sdk.llm.prompts.rollback(id=prompt.id, version=1)

  print("Revertido para v" + str(rolled_back.active_version))
  # active_version=1, latest_version=2

  # 6. Limpeza
  sdk.llm.prompts.delete(id=prompt.id)
  ```

  ```bash bash theme={null}
  # 1. Crie um prompt
  curl https://apigw.mka1.com/api/v1/llm/prompts \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user-123' \
    --data '{
      "name": "support-reply",
      "template": "Hi {{customer}}, thanks for contacting us about {{issue}}."
    }'
  # → { "id": "prompt_abc123", "active_version": 1, ... }

  # 2. Crie a v2 com um tom mais amigável
  curl https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/versions \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user-123' \
    --data '{
      "template": "Hey {{customer}}! We got your message about {{issue}} and are on it."
    }'

  # 3. Obtenha o prompt com variáveis renderizadas
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123?variables=%7B%22customer%22%3A%22Alice%22%2C%22issue%22%3A%22billing%22%7D" \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user-123'

  # 4. Visualize o histórico de versões
  curl "https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/versions?order=asc" \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user-123'

  # 5. Reverter para a v1
  curl https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123/rollback \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user-123' \
    --data '{ "version": 1 }'

  # 6. Exclua o prompt
  curl https://apigw.mka1.com/api/v1/llm/prompts/prompt_abc123 \
    --request DELETE \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user-123'
  ```
</CodeGroup>

## Detalhes do comportamento

| Aspecto                | Detalhe                                                                                                 |
| ---------------------- | ------------------------------------------------------------------------------------------------------- |
| Versionamento          | Imutável — cada alteração no modelo cria uma nova versão que não pode ser modificada                    |
| Versão ativa           | Novas versões são ativadas automaticamente; use a reversão para alternar para outra versão              |
| Reversão               | Não destrutivo — define `active_version` sem excluir versões mais recentes                              |
| Paginação              | Baseada em cursor para listar prompts — use o parâmetro `after` com `first_id`/`last_id` da resposta    |
| Renderização do modelo | No servidor — passe o parâmetro de consulta `variables`; marcadores não correspondentes são preservados |
| Propriedade            | Por chave de API — prompts são isolados por contexto de autenticação                                    |
| Concorrência           | Detecção de conflito — criação concorrente de versões retorna 409                                       |

## Próximos passos

* [Gerar uma resposta](/pt/docs/generate-a-response) — use prompts renderizados como entrada para a API de Respostas
* [Extrair dados estruturados](/pt/docs/extract-structured-data) — combine prompts com extração estruturada
* [Conversas](/pt/docs/conversations) — gerencie trocas multi-turno com prompts de sistema versionados