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

# Gerar uma resposta

> Use o recurso Responses da API MKA1 para gerar texto, enviar mensagens estruturadas e continuar trocas de múltiplas interações.

Use o recurso Responses quando você quiser que a API MKA1 retorne texto.
Comece com uma string simples para prompts básicos.
Use itens de mensagem quando precisar de papéis explícitos ou estado de conversa.

## Envie um prompt simples

Passe uma string em `input` para uma solicitação de turno único.
A resposta inclui o texto gerado em `output_text`.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-pt \
    --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-pt',
    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-pt',
    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-pt",
      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-pt",
      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-pt",
      "input": "Write a one-sentence summary of the MKA1 API."
    }'
  ```
</CodeGroup>

Se você não estiver agindo em nome de um usuário final, omita `X-On-Behalf-Of`.

## Adicione instruções

Use `instructions` para definir o comportamento antes que o modelo veja a entrada do usuário.
Mantenha as instruções curtas e específicas.

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

## Envie mensagens estruturadas

Use um array de itens de mensagem em `input` quando quiser papéis explícitos.
Cada item de mensagem usa `type`, `role` e `content`.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create --body '{
    "model": "meetkai:functionary-pt",
    "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-pt',
    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-pt',
    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-pt",
      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-pt",
      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-pt",
      "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>

Esse padrão é útil quando você quer que o corpo da requisição carregue o histórico de mensagens diretamente.

## Continue uma troca de múltiplas interações

Use `previous_response_id` para continuar a partir de uma resposta anterior sem reenviar todo o histórico.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-pt \
    --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-pt',
    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-pt',
    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-pt",
      Input = ResponsesCreateRequestInput.CreateStr("Write a one-line product tagline."),
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-pt",
      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-pt",
      "previous_response_id": "resp_123",
      "input": "Now turn that into an email subject line."
    }'
  ```
</CodeGroup>

Se você precisa de um contêiner de conversa reutilizável, crie um com o recurso Conversations e depois passe o ID da conversa em `conversation`.

<CodeGroup>
  ```bash CLI theme={null}
  # Crie uma conversa
  mka1 llm conversations create --body '{
    "metadata": { "session_id": "web-42" }
  }'

  # Use a conversa em uma requisição de resposta
  mka1 llm responses create \
    --model meetkai:functionary-pt \
    --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-pt',
    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-pt',
    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-pt",
      conversation=conv.id,
      input="What should I ask next to refine this draft?",
  )
  ```

  ```bash bash theme={null}
  # Criar conversa
  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 conversa em uma requisição de resposta
  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-pt",
      "conversation": "conv_123",
      "input": "What should I ask next to refine this draft?"
    }'
  ```
</CodeGroup>

Veja as páginas de Conversations e Responses na [Referência da API](/pt/api-reference/introduction) para o fluxo completo de recursos.

## Transmita texto conforme ele é gerado

Defina `stream` como `true` para receber eventos enviados pelo servidor em vez de aguardar a resposta completa.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-pt \
    --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-pt',
    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-pt',
    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-pt",
      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-pt",
      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-pt",
      "input": "Write three release notes bullets for our docs update.",
      "stream": true
    }'
  ```
</CodeGroup>

Use streaming quando quiser renderizar a saída parcial conforme ela chega.

## Próximos passos

* Revise a [visão geral da API](/pt/api-reference/introduction) para detalhes sobre autenticação e URL base
* Veja [respostas em segundo plano](/pt/docs/background-responses) quando precisar delegar trabalhos longos e buscar ou transmitir resultados
* Veja [gerenciar conversas](/pt/docs/conversations) para organizar trocas de múltiplas interações em contêineres de conversa reutilizáveis
* Veja [gerenciar agentes](/pt/docs/managing-agents) quando precisar de definições de agente reutilizáveis e execuções persistentes