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

# Gestionar conversaciones

> Almacena el estado de la conversación en la API de MKA1, agrega elementos de mensajes y continúa un flujo de respuesta sin reenviar todo el historial.

Utiliza el recurso de Conversaciones cuando quieras que la API de MKA1 mantenga el estado de la conversación entre solicitudes de Respuestas.
Esto es útil para chats de varios turnos, hilos de soporte y flujos de trabajo donde quieras recuperar o editar el historial guardado más adelante.

## Crear una conversación

Crea primero una conversación.
Puedes adjuntar metadatos para mantener tu propio contexto de sesión o enrutamiento.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm conversations create \
    -H 'X-On-Behalf-Of: <end-user-id>' \
    --body '{
      "metadata": {
        "session_id": "web-42",
        "channel": "support"
      }
    }'
  ```

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

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

  const conv = await mka1.llm.conversations.create({
    metadata: {
      session_id: 'web-42',
      channel: 'support',
    },
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai';

  const openai = new OpenAI({
    apiKey: '<mka1-api-key>',
    baseURL: 'https://apigw.mka1.com/api/v1/llm/',
    defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  const conv = await openai.conversations.create({
    metadata: {
      session_id: 'web-42',
      channel: 'support',
    },
  });
  ```

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

  var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

  var conv = await sdk.Llm.Conversations.CreateAsync(new CreateConversationRequest()
  {
      Metadata = new Dictionary<string, string> { { "session_id", "web-42" } },
  });
  ```

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

  sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

  conv = sdk.llm.conversations.create(
      metadata={"session_id": "web-42"},
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/conversations \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "metadata": {
        "session_id": "web-42",
        "channel": "support"
      }
    }'
  ```
</CodeGroup>

Si tu solicitud no está asociada a un usuario final específico, omite `X-On-Behalf-Of`.
Consulta la [guía de autenticación](/es/docs/authentication) para ver el patrón completo.

## Agregar elementos a la conversación

Agrega uno o más elementos con `POST /api/v1/llm/conversations/{conversation_id}/items`.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm conversations create-items \
    --conversation-id conv_abc123 \
    --body '{
      "items": [
        {
          "type": "message",
          "role": "user",
          "content": "Summarize the latest support ticket."
        }
      ]
    }'
  ```

  ```ts MKA1 SDK theme={null}
  const items = await mka1.llm.conversations.createItems({
    conversationId: 'conv_abc123',
    createItemsRequest: {
      items: [
        {
          type: 'message',
          role: 'user',
          content: 'Summarize the latest support ticket.',
        },
      ],
    },
  }, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });
  ```

  ```ts OpenAI SDK theme={null}
  const items = await openai.conversations.items.create('conv_abc123', {
    items: [
      {
        type: 'message',
        role: 'user',
        content: 'Summarize the latest support ticket.',
      },
    ],
  });
  ```

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

  var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

  var items = await sdk.Llm.Conversations.CreateItemsAsync("conv_abc123", new CreateItemsRequest()
  {
      Items = new List<Item>
      {
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.User,
              Content = InputMessageContent1.CreateStr("Summarize the latest support ticket."),
          }),
      },
  });
  ```

  ```python Python SDK theme={null}
  sdk.llm.conversations.create_items(
      conversation_id=conv.id,
      items=[
          {"type": "message", "role": "user", "content": "What is MKA1?"},
          {"type": "message", "role": "assistant", "content": "MKA1 is an AI platform."},
      ],
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/conversations/conv_abc123/items \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "items": [
        {
          "type": "message",
          "role": "user",
          "content": "Summarize the latest support ticket."
        }
      ]
    }'
  ```
</CodeGroup>

Utiliza este endpoint cuando quieras escribir el historial explícitamente antes de llamar al recurso de Respuestas.

## Continuar el flujo con el recurso de Respuestas

Pasa el ID de la conversación en tu siguiente solicitud de Respuestas.
Esto permite que la API de MKA1 utilice el estado de conversación guardado.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --conversation conv_abc123 \
    --input '"Turn that summary into a customer-ready reply."'
  ```

  ```ts MKA1 SDK theme={null}
  const result = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    conversation: 'conv_abc123',
    input: 'Turn that summary into a customer-ready reply.',
  });
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    conversation: 'conv_abc123',
    input: 'Turn that summary into a customer-ready reply.',
    stream: false,
  });
  ```

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

  var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

  var conv = await sdk.Llm.Conversations.CreateAsync(new CreateConversationRequest()
  {
      Metadata = new Dictionary<string, string> { { "session_id", "csharp-test" } },
  });

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Conversation = ResponsesCreateRequestConversation.CreateStr(conv.ConversationObject!.Id),
      Input = ResponsesCreateRequestInput.CreateStr("Turn that summary into a customer-ready reply."),
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      conversation="conv_abc123",
      input="Turn that summary into a customer-ready reply.",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "meetkai:functionary-es-mini",
      "conversation": "conv_abc123",
      "input": "Turn that summary into a customer-ready reply."
    }'
  ```
</CodeGroup>

También puedes seguir agregando elementos a la misma conversación a medida que crece el intercambio.

## Leer, actualizar o limpiar una conversación

Utiliza los endpoints de Conversaciones para:

* Listar conversaciones para la cuenta actual o usuario final (`GET /api/v1/llm/conversations`).
* Filtrar listas con `after`, `limit`, `order`, `metadata` y `search`.
* Obtener una conversación por ID (`GET /api/v1/llm/conversations/{conversation_id}`).
* Actualizar los metadatos de la conversación (`POST /api/v1/llm/conversations/{conversation_id}`).
* Listar elementos en una conversación (`GET /api/v1/llm/conversations/{conversation_id}/items`).
* Obtener un solo elemento (`GET /api/v1/llm/conversations/{conversation_id}/items/{item_id}`).
* Eliminar elementos (uno o varios) mediante:
  * `DELETE /api/v1/llm/conversations/{conversation_id}/items/{item_id}`
  * `DELETE /api/v1/llm/conversations/{conversation_id}/items` con `{ "item_ids": ["item_..."] }`
* Eliminar la conversación (`DELETE /api/v1/llm/conversations/{conversation_id}`).

Nota: eliminar una conversación **no** elimina sus elementos.

Utiliza la pestaña de Referencia de API para ver la forma exacta de las solicitudes y respuestas de cada operación.

## Cuándo usar conversaciones vs `previous_response_id`

Utiliza una conversación cuando:

* Quieres un contenedor reutilizable para muchos turnos.
* Necesitas listar o gestionar los elementos guardados más tarde.
* Quieres adjuntar metadatos al hilo en curso.

Utiliza `previous_response_id` cuando:

* Solo necesitas continuar desde una respuesta anterior.
* No necesitas un recurso de conversación almacenado por separado.

Para el patrón del lado de la respuesta, consulta [generar una respuesta](/es/docs/generate-a-response).