> ## 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.

# Repositorio de prompts

> Gestiona plantillas de prompts versionadas con historial de cambios, reversión y renderizado de variables a través de la API de Prompts.

La API de Prompts te permite almacenar, versionar y gestionar plantillas de prompts de forma centralizada.
Cada cambio en la plantilla crea una versión inmutable, dándote un historial completo de cambios
con la capacidad de revertir a cualquier versión anterior en cualquier momento.

Las plantillas admiten marcadores de posición `{{variable}}` que se renderizan del lado del servidor cuando
recuperas un prompt, por lo que puedes reutilizar la misma plantilla en diferentes contextos.

## Crear un prompt

Crea un prompt con un nombre y una plantilla. La primera versión se crea automáticamente.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts create \
    --body '{
      "name": "greeting",
      "description": "Una plantilla de saludo simple",
      "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: 'Una plantilla de saludo simple',
    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 = "Una plantilla de saludo simple",
          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="Una plantilla de saludo simple",
      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": "Una plantilla de saludo simple",
      "template": "Hello, {{name}}! Welcome to {{company}}.",
      "metadata": { "team": "onboarding" }
    }'
  ```
</CodeGroup>

## Recuperar un prompt con variables renderizadas

Pasa `variables` como parámetro de consulta para renderizar la plantilla con tus valores.
Los marcadores de posición no coincidentes se dejan tal cual.

<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}
  # Codifica en URL el JSON de variables
  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

Recupera una lista paginada de todos los prompts. Usa `after` para paginación basada en 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) {
    // Obtener la siguiente página usando el ú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>

## Actualizar metadatos del prompt

Actualiza el nombre, la descripción o los metadatos de un prompt. Para cambiar la plantilla,
crea una nueva versión en su lugar.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm prompts update \
    --id prompt_abc123 \
    --body '{
      "name": "welcome-greeting",
      "description": "Saludo actualizado para el flujo de bienvenida",
      "metadata": { "team": "onboarding", "reviewed": true }
    }'
  ```

  ```ts MKA1 SDK theme={null}
  const updated = await mka1.llm.prompts.update({
    id: promptId,
    requestBody: {
      name: 'welcome-greeting',
      description: 'Saludo actualizado para el flujo de bienvenida',
      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 = "Saludo actualizado para el flujo de bienvenida",
          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="Saludo actualizado para el flujo de bienvenida",
      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": "Saludo actualizado para el flujo de bienvenida",
      "metadata": { "team": "onboarding", "reviewed": true }
    }'
  ```
</CodeGroup>

## Crear una nueva versión

Cada cambio en la plantilla crea una nueva versión. La nueva versión se activa automáticamente.

<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); // El nuevo texto de la plantilla
  ```

  ```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); // El nuevo texto de la plantilla
  ```

  ```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)  # El nuevo texto de la plantilla
  ```

  ```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>

## Ver historial de versiones

Lista todas las versiones de un prompt para ver su historial completo de cambios.

<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 una versión específica

Obtén una versión concreta por su número de versión.

<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>

## Revertir a una versión anterior

La reversión establece una versión anterior como la versión activa. Todas las versiones se conservan — la reversión
no elimina las versiones más recientes, por lo que siempre puedes volver a avanzar.

<CodeGroup>
  ```bash CLI theme={null}
  # Actualmente en la versión 2, volver a la versión 1
  mka1 llm prompts rollback --id prompt_abc123 --version-param 1
  ```

  ```ts MKA1 SDK theme={null}
  // Actualmente en la versión 2, volver a la versión 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 (sigue existiendo)
  ```

  ```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"
  );

  // Actualmente en la versión 2, volver a la versión 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 (sigue existiendo)
  ```

  ```python Python SDK theme={null}
  # Actualmente en la versión 2, volver a la versión 1
  rolled_back = sdk.llm.prompts.rollback(id=prompt_id, version=1)

  print(rolled_back.active_version)  # 1
  print(rolled_back.latest_version)  # 2 (sigue existiendo)
  ```

  ```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>

## Eliminar un prompt

Eliminar un prompt lo elimina a él y a todas sus versiones de forma permanente.

<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>

## Ejemplo completo: flujo de trabajo de versionado y reversión

Este ejemplo demuestra el ciclo de vida completo — crear un prompt, iterar sobre la
plantilla, revisar el historial y revertir.

<CodeGroup>
  ```bash CLI theme={null}
  # 1. Crear un prompt con la plantilla 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. Publicar v2 con un tono más amigable
  mka1 llm prompts create-version \
    --id prompt_abc123 \
    --body '{
      "template": "Hey {{customer}}! We got your message about {{issue}} and are on it."
    }'

  # 3. Recuperar el prompt con variables renderizadas
  mka1 llm prompts get \
    --id prompt_abc123 \
    --variables '{"customer":"Alice","issue":"billing"}'

  # 4. Revisar el historial de versiones
  mka1 llm prompts list-versions --id prompt_abc123 --order asc

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

  # 6. Limpiar
  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. Crear un prompt con la plantilla inicial
  const prompt = await mka1.llm.prompts.create({
    name: 'support-reply',
    template: 'Hi {{customer}}, thanks for contacting us about {{issue}}.',
  }, { headers });

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

  // 2. Publicar v2 con un tono más amigable
  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('Creada v2:', v2.version);

  // 3. Recuperar el prompt — la versión activa ahora es v2
  const current = await mka1.llm.prompts.get({
    id: prompt.id,
    variables: JSON.stringify({ customer: 'Alice', issue: 'billing' }),
  }, { headers });

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

  // 4. Revisar el historial de versiones
  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. Revertir a v1
  const rolledBack = await mka1.llm.prompts.rollback({
    id: prompt.id,
    requestBody: {
      version: 1,
    },
  }, { headers });

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

  // 6. Limpiar
  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. Crear un prompt con la plantilla 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($"Creado: {promptId} v1");

  // 2. Publicar v2 con un tono más amigable
  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($"Creada v2: {v2.CreateVersionResponse!.Version}");

  // 3. Recuperar el prompt con variables renderizadas
  var current = await sdk.Llm.Prompts.GetAsync(
      id: promptId,
      variables: "{\"customer\":\"Alice\",\"issue\":\"billing\"}"
  );

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

  // 4. Revisar el historial de versiones
  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. Revertir a v1
  var rolledBack = await sdk.Llm.Prompts.RollbackAsync(
      id: promptId,
      body: new RollbackPromptRequestBody { Version = 1 }
  );

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

  // 6. Limpiar
  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. Crear un prompt con la plantilla inicial
  prompt = sdk.llm.prompts.create(
      name="support-reply",
      template="Hi {{customer}}, thanks for contacting us about {{issue}}.",
  )

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

  # 2. Publicar v2 con un tono más amigable
  v2 = sdk.llm.prompts.create_version(
      id=prompt.id,
      template="Hey {{customer}}! We got your message about {{issue}} and are on it.",
  )

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

  # 3. Recuperar el prompt — la versión activa ahora es v2
  current = sdk.llm.prompts.get(
      id=prompt.id,
      variables='{"customer": "Alice", "issue": "billing"}',
  )

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

  # 4. Revisar el historial de versiones
  history = sdk.llm.prompts.list_versions(id=prompt.id)

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

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

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

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

  ```bash bash theme={null}
  # 1. Crear un 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. Crear v2 con un tono más amigable
  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. Obtener el prompt con variables 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. Ver historial de versiones
  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. Revertir 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. Eliminar el 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>

## Detalles de comportamiento

| Aspecto                   | Detalle                                                                                                        |
| ------------------------- | -------------------------------------------------------------------------------------------------------------- |
| Versionado                | Inmutable — cada cambio en la plantilla crea una nueva versión que no puede ser modificada                     |
| Versión activa            | Las nuevas versiones se activan automáticamente; usa la reversión para cambiar a otra versión                  |
| Reversión                 | No destructiva — establece `active_version` sin eliminar versiones más recientes                               |
| Paginación                | Basada en cursor para listar prompts — usa el parámetro `after` con `first_id`/`last_id` de la respuesta       |
| Renderizado de plantillas | Del lado del servidor — pasa el parámetro de consulta `variables`; los marcadores no coincidentes se conservan |
| Propiedad                 | Por clave de API — los prompts están aislados por contexto de autenticación                                    |
| Concurrencia              | Detección de conflictos — la creación concurrente de versiones devuelve 409                                    |

## Próximos pasos

* [Generar una respuesta](/es/docs/generate-a-response) — usa prompts renderizados como entrada para la API de Respuestas
* [Extraer datos estructurados](/es/docs/extract-structured-data) — combina prompts con extracción estructurada
* [Conversaciones](/es/docs/conversations) — gestiona intercambios de varios turnos con prompts de sistema versionados