Gerar uma resposta

Use o recurso Responses quando quiser que a API MKA1 retorne texto. Comece com uma string simples para prompts simples. Use itens de mensagem quando precisar de funções explícitas ou estado da conversa.

Enviar um prompt simples

Passe uma string em input para uma solicitação de uma única interação. A resposta inclui o texto gerado em output_text.

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --input '"Escreva um resumo da API MKA1 em uma frase."' \
  -H 'X-On-Behalf-Of: <end-user-id>'

import { SDK } from '@meetkai/mka1';

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

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>', // optional — attribute the request to one of your end users
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Escreva um resumo da API MKA1 em uma frase.',
  },
});

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: 'Escreva um resumo da API MKA1 em uma frase.',
  stream: false,
});

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(
        "Escreva um resumo da API MKA1 em uma frase."),
});

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Escreva um resumo da API MKA1 em uma frase.",
    http_headers={"X-On-Behalf-Of": "<end-user-id>"},
)

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": "Escreva um resumo da API MKA1 em uma frase."
  }'

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

Adicionar instruções

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

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --instructions 'Você é um assistente de suporte. Responda em português simples. Mantenha as respostas com menos de 80 palavras.' \
  --input '"Explique para que são usados os embeddings."'

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    instructions: 'Você é um assistente de suporte. Responda em português simples. Mantenha as respostas com menos de 80 palavras.',
    input: 'Explique para que são usados os embeddings.',
  },
});

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  instructions: 'Você é um assistente de suporte. Responda em português simples. Mantenha as respostas com menos de 80 palavras.',
  input: 'Explique para que são usados os embeddings.',
  stream: false,
});

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 = "Você é um assistente de suporte. Responda em português simples. Mantenha as respostas com menos de 80 palavras.",
    Input = ResponsesCreateRequestInput.CreateStr("Explique para que são usados os embeddings."),
});

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    instructions="Você é um assistente de suporte. Responda em português simples. Mantenha as respostas com menos de 80 palavras.",
    input="Explique para que são usados os embeddings.",
)

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": "Você é um assistente de suporte. Responda em português simples. Mantenha as respostas com menos de 80 palavras.",
    "input": "Explique para que são usados os embeddings."
  }'

Enviar mensagens estruturadas

Use uma matriz de itens de mensagem em input quando quiser funções explícitas. Cada item de mensagem usa type, role e content.

mka1 llm responses create --body '{
  "model": "meetkai:functionary-pt",
  "input": [
    { "type": "message", "role": "developer", "content": "Responda como um redator técnico. Mantenha a resposta concisa." },
    { "type": "message", "role": "user", "content": "Elabore uma breve atualização de produto sobre tempos de resposta mais rápidos." }
  ]
}'

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      { type: 'message', role: 'developer', content: 'Responda como um redator técnico. Mantenha a resposta concisa.' },
      { type: 'message', role: 'user', content: 'Elabore uma breve atualização de produto sobre tempos de resposta mais rápidos.' },
    ],
  },
});

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    { type: 'message', role: 'developer', content: 'Responda como um redator técnico. Mantenha a resposta concisa.' },
    { type: 'message', role: 'user', content: 'Elabore uma breve atualização de produto sobre tempos de resposta mais rápidos.' },
  ],
  stream: false,
});

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(
                "Responda como um redator técnico. Mantenha a resposta concisa."),
        }),
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateStr(
                "Elabore uma breve atualização de produto sobre tempos de resposta mais rápidos."),
        }),
    }),
});

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[
        {"type": "message", "role": "developer", "content": "Responda como um redator técnico. Mantenha a resposta concisa."},
        {"type": "message", "role": "user", "content": "Elabore uma breve atualização de produto sobre tempos de resposta mais rápidos."},
    ],
)

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": "Responda como um redator técnico. Mantenha a resposta concisa." },
      { "type": "message", "role": "user", "content": "Elabore uma breve atualização de produto sobre tempos de resposta mais rápidos." }
    ]
  }'

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

Continuar uma troca de várias interações

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

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --previous-response-id resp_123 \
  --input '"Agora transforme isso em uma linha de assunto de e-mail."'

const second = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    previousResponseId: 'resp_123',
    input: 'Agora transforme isso em uma linha de assunto de e-mail.',
  },
});

const second = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  previous_response_id: 'resp_123',
  input: 'Agora transforme isso em uma linha de assunto de e-mail.',
  stream: false,
});

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("Escreva um slogan de produto em uma linha."),
});

// Second request: continue from the first response
var second = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    PreviousResponseId = first.Id,
    Input = ResponsesCreateRequestInput.CreateStr("Agora transforme isso em uma linha de assunto de e-mail."),
});

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    previous_response_id="resp_123",
    input="Agora transforme isso em uma linha de assunto de e-mail.",
)

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": "Agora transforme isso em uma linha de assunto de e-mail."
  }'

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

# Criar uma conversa
mka1 llm conversations create --body '{
  "metadata": { "session_id": "web-42" }
}'

# Usar a conversa em uma solicitação de resposta
mka1 llm responses create \
  --model meetkai:functionary-pt \
  --conversation conv_123 \
  --input '"O que devo perguntar a seguir para refinar este rascunho?"'

const conv = await mka1.llm.conversations.create({
  createConversationRequest: {
    metadata: { session_id: 'web-42' },
  },
});

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    conversation: conv.id,
    input: 'O que devo perguntar a seguir para refinar este rascunho?',
  },
});

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: 'O que devo perguntar a seguir para refinar este rascunho?',
  stream: false,
});

using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;

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

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

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

res = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    conversation=conv.id,
    input="O que devo perguntar a seguir para refinar este rascunho?",
)

# 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 a conversa em uma solicitaçã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": "O que devo perguntar a seguir para refinar este rascunho?"
  }'

Consulte as páginas Conversations e Responses na Referência da API para conhecer o fluxo de trabalho completo do recurso.

Transmitir texto à medida que é gerado

Defina stream como true para receber eventos enviados pelo servidor em vez de esperar pela resposta completa.

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --input '"Escreva três tópicos de notas de versão para nossa atualização de documentação."' \
  --stream

import { CreateAcceptEnum } from '@meetkai/mka1/sdk/responses';

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Escreva três tópicos de notas de versão para nossa atualização de documentação.',
    stream: true,
  },
}, { acceptHeaderOverride: CreateAcceptEnum.textEventStream });

const stream = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Escreva três tópicos de notas de versão para nossa atualização de documentação.',
  stream: true,
});

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

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(
        "Escreva três tópicos de notas de versão para nossa atualização de documentação."),
    Stream = true,
});

stream = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Escreva três tópicos de notas de versão para nossa atualização de documentação.",
    stream=True,
)

for event in stream:
    if event.data.type == "response.output_text.delta":
        print(event.data.delta, end="", flush=True)

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": "Escreva três tópicos de notas de versão para nossa atualização de documentação.",
    "stream": true
  }'

Use streaming quando quiser renderizar a saída parcial à medida que ela chega.

Próximas etapas

Consulte a visão geral da API para detalhes sobre autenticação e URL base
Consulte respostas em segundo plano quando precisar delegar trabalhos de longa duração e consultar ou transmitir os resultados
Consulte gerenciar conversas para organizar trocas de várias interações em contêineres de conversa reutilizáveis
Consulte gerenciar agentes quando quiser definições de agentes reutilizáveis e execuções persistentes

⌘I

Primeiros passos

Respostas

Recursos

Computação

CLI

Receitas

Benchmarks

Infraestrutura

Gerar uma resposta

Enviar um prompt simples

Adicionar instruções

Enviar mensagens estruturadas

Continuar uma troca de várias interações

Transmitir texto à medida que é gerado

Próximas etapas

​Enviar um prompt simples

​Adicionar instruções

​Enviar mensagens estruturadas

​Continuar uma troca de várias interações

​Transmitir texto à medida que é gerado

​Próximas etapas

Enviar um prompt simples

Adicionar instruções

Enviar mensagens estruturadas

Continuar uma troca de várias interações

Transmitir texto à medida que é gerado

Próximas etapas