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

# Generar una respuesta

> Utiliza el recurso de Respuestas de la API MKA1 para generar texto, enviar mensajes estructurados y continuar intercambios de varios turnos.

Utiliza el recurso de Respuestas cuando quieras que la API MKA1 devuelva texto.
Comienza con una cadena simple para prompts sencillos.
Utiliza elementos de mensaje cuando necesites roles explícitos o estado de conversación.

## Enviar un prompt simple

Pasa una cadena en `input` para una solicitud de un solo turno.
La respuesta incluye el texto generado en `output_text`.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --input '"Write a one-sentence summary of the MKA1 API."' \
    -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.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write a one-sentence summary of the MKA1 API.',
  }, { 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 response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write a one-sentence summary of the MKA1 API.',
    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 res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateStr(
          "Write a one-sentence summary of the MKA1 API."),
  });
  ```

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

  sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

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

  ```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",
      "input": "Write a one-sentence summary of the MKA1 API."
    }'
  ```
</CodeGroup>

Si no estás actuando en nombre de un usuario final, omite `X-On-Behalf-Of`.

## Agregar instrucciones

Utiliza `instructions` para definir el comportamiento antes de que el modelo vea la entrada del usuario.
Mantén las instrucciones cortas y específicas.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --instructions 'You are a support assistant. Reply in plain English. Keep answers under 80 words.' \
    --input '"Explain what embeddings are used for."'
  ```

  ```ts MKA1 SDK theme={null}
  const result = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    instructions: 'You are a support assistant. Reply in plain English. Keep answers under 80 words.',
    input: 'Explain what embeddings are used for.',
  });
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    instructions: 'You are a support assistant. Reply in plain English. Keep answers under 80 words.',
    input: 'Explain what embeddings are used for.',
    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 res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Instructions = "You are a support assistant. Reply in plain English. Keep answers under 80 words.",
      Input = ResponsesCreateRequestInput.CreateStr("Explain what embeddings are used for."),
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      instructions="You are a support assistant. Reply in plain English. Keep answers under 80 words.",
      input="Explain what embeddings are used for.",
  )
  ```

  ```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",
      "instructions": "You are a support assistant. Reply in plain English. Keep answers under 80 words.",
      "input": "Explain what embeddings are used for."
    }'
  ```
</CodeGroup>

## Enviar mensajes estructurados

Utiliza un arreglo de elementos de mensaje en `input` cuando quieras roles explícitos.
Cada elemento de mensaje utiliza `type`, `role` y `content`.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create --body '{
    "model": "meetkai:functionary-es-mini",
    "input": [
      { "type": "message", "role": "developer", "content": "Answer as a technical writer. Keep the reply concise." },
      { "type": "message", "role": "user", "content": "Draft a short product update about faster response times." }
    ]
  }'
  ```

  ```ts MKA1 SDK theme={null}
  const result = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: [
      { type: 'message', role: 'developer', content: 'Answer as a technical writer. Keep the reply concise.' },
      { type: 'message', role: 'user', content: 'Draft a short product update about faster response times.' },
    ],
  });
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: [
      { type: 'message', role: 'developer', content: 'Answer as a technical writer. Keep the reply concise.' },
      { type: 'message', role: 'user', content: 'Draft a short product update about faster response times.' },
    ],
    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 res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
      {
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.Developer,
              Content = InputMessageContent1.CreateStr(
                  "Answer as a technical writer. Keep the reply concise."),
          }),
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.User,
              Content = InputMessageContent1.CreateStr(
                  "Draft a short product update about faster response times."),
          }),
      }),
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      input=[
          {"type": "message", "role": "developer", "content": "Answer as a technical writer. Keep the reply concise."},
          {"type": "message", "role": "user", "content": "Draft a short product update about faster response times."},
      ],
  )
  ```

  ```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",
      "input": [
        { "type": "message", "role": "developer", "content": "Answer as a technical writer. Keep the reply concise." },
        { "type": "message", "role": "user", "content": "Draft a short product update about faster response times." }
      ]
    }'
  ```
</CodeGroup>

Este patrón es útil cuando quieres que el cuerpo de la solicitud lleve directamente el historial de mensajes.

## Continuar un intercambio de varios turnos

Utiliza `previous_response_id` para continuar desde una respuesta anterior sin reenviar todo el historial.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --previous-response-id resp_123 \
    --input '"Now turn that into an email subject line."'
  ```

  ```ts MKA1 SDK theme={null}
  const second = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    previousResponseId: 'resp_123',
    input: 'Now turn that into an email subject line.',
  });
  ```

  ```ts OpenAI SDK theme={null}
  const second = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    previous_response_id: 'resp_123',
    input: 'Now turn that into an email subject line.',
    stream: false,
  });
  ```

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

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

  // First request
  var first = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateStr("Write a one-line product tagline."),
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      previous_response_id="resp_123",
      input="Now turn that into an email subject line.",
  )
  ```

  ```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",
      "previous_response_id": "resp_123",
      "input": "Now turn that into an email subject line."
    }'
  ```
</CodeGroup>

Si necesitas un contenedor de conversación reutilizable, créalo con el recurso de Conversaciones y luego pasa el ID de la conversación en `conversation`.

<CodeGroup>
  ```bash CLI theme={null}
  # Crear una conversación
  mka1 llm conversations create --body '{
    "metadata": { "session_id": "web-42" }
  }'

  # Usar la conversación en una solicitud de respuesta
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --conversation conv_123 \
    --input '"What should I ask next to refine this draft?"'
  ```

  ```ts MKA1 SDK theme={null}
  const conv = await mka1.llm.conversations.create({
    metadata: { session_id: 'web-42' },
  });

  const result = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    conversation: conv.id,
    input: 'What should I ask next to refine this draft?',
  });
  ```

  ```ts OpenAI SDK theme={null}
  const conv = await openai.conversations.create({
    metadata: { session_id: 'web-42' },
  });

  const response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    conversation: conv.id,
    input: 'What should I ask next to refine this draft?',
    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", "web-42" } },
  });
  ```

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

  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      conversation=conv.id,
      input="What should I ask next to refine this draft?",
  )
  ```

  ```bash bash theme={null}
  # Crear conversación
  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" }
    }'

  # Usar conversación en una solicitud de respuesta
  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_123",
      "input": "What should I ask next to refine this draft?"
    }'
  ```
</CodeGroup>

Consulta las páginas de Conversaciones y Respuestas en la [Referencia de la API](/es/api-reference/introduction) para ver el flujo de trabajo completo del recurso.

## Transmitir texto a medida que se genera

Establece `stream` en `true` para recibir eventos enviados por el servidor en lugar de esperar la respuesta completa.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --input '"Write three release notes bullets for our docs update."' \
    --stream
  ```

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

  const result = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write three release notes bullets for our docs update.',
    stream: true,
  }, { acceptHeaderOverride: CreateAcceptEnum.TextEventStream });
  ```

  ```ts OpenAI SDK theme={null}
  const stream = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write three release notes bullets for our docs update.',
    stream: true,
  });

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

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

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

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateStr(
          "Write three release notes bullets for our docs update."),
      Stream = true,
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      input="Write three release notes bullets for our docs update.",
      stream=True,
  )
  ```

  ```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",
      "input": "Write three release notes bullets for our docs update.",
      "stream": true
    }'
  ```
</CodeGroup>

Utiliza el streaming cuando quieras mostrar la salida parcial a medida que llega.

## Próximos pasos

* Revisa la [visión general de la API](/es/api-reference/introduction) para detalles de autenticación y URL base
* Consulta [respuestas en segundo plano](/es/docs/background-responses) cuando necesites delegar trabajos de larga duración y hacer polling o streaming para obtener resultados
* Consulta [gestionar conversaciones](/es/docs/conversations) para organizar intercambios de varios turnos en contenedores de conversación reutilizables
* Consulta [gestionar agentes](/es/docs/managing-agents) cuando necesites definiciones de agente reutilizables y ejecuciones persistentes