Memória de longo prazo

A ferramenta history fornece aos modelos memória de longo prazo que persiste entre sessões. Quando ativada, cada par de solicitação e resposta é automaticamente armazenado e indexado. O modelo pode então pesquisar semanticamente interações anteriores para recuperar informações de conversas passadas.

Como funciona

Adicione { type: "history" } ao array tools em sua solicitação
O modelo recebe uma função history que pode chamar com uma consulta de pesquisa
Conversas anteriores são pesquisadas usando embeddings vetoriais para similaridade semântica
Após a conclusão de cada resposta, a mensagem do usuário e a resposta do assistente são armazenadas automaticamente em segundo plano

A memória é delimitada por usuário final — cada ID de usuário X-On-Behalf-Of recebe um armazenamento de histórico isolado. Usuários finais diferentes não podem ver o histórico uns dos outros.

Ativar a ferramenta de histórico

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --body '{
    "input": "Lembre-se disto: minha cor favorita é azul.",
    "tools": [{ "type": "history" }],
    "store": true
  }' \
  -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>', // opcional — atribua a solicitação a um de seus usuários finais
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Lembre-se disto: minha cor favorita é azul.',
    tools: [{ type: 'history' }],
    store: true,
  },
});

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: 'Lembre-se disto: minha cor favorita é azul.',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

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

var sdk = new SDK(
    bearerAuth: $"Bearer {YOUR_API_KEY}",
    serverUrl: "https://apigw.mka1.com"
);

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Lembre-se disto: minha cor favorita é azul."),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateHistoryToolDefinition(new HistoryToolDefinition()),
    },
    Store = true,
});

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Lembre-se disto: minha cor favorita é azul.",
    tools=[{"type": "history"}],
    store=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": "Lembre-se disto: minha cor favorita é azul.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Defina store: true para que a conversa seja persistida e fique disponível para recuperação futura.

Recuperar informações de uma sessão anterior

Em uma solicitação posterior — mesmo minutos, horas ou dias depois — o modelo pode pesquisar seu histórico para encontrar interações anteriores relevantes. O modelo decide quando chamar a ferramenta de histórico com base na pergunta do usuário.

mka1 llm responses create \
  --model meetkai:functionary-pt \
  --body '{
    "input": "Qual é a minha cor favorita?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

// Em uma nova sessão, o modelo pode recuperar conversas anteriores
const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Qual é a minha cor favorita?',
    tools: [{ type: 'history' }],
    store: true,
  },
});

// O modelo chama a ferramenta de histórico, encontra a conversa anterior,
// e responde: "Sua cor favorita é azul."

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Qual é a minha cor favorita?',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

// O modelo chama a ferramenta de histórico, encontra a conversa anterior,
// e responde: "Sua cor favorita é azul."

// Em uma nova sessão, o modelo pode recuperar conversas anteriores
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr("Qual é a minha cor favorita?"),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateHistoryToolDefinition(new HistoryToolDefinition()),
    },
    Store = true,
});

// O modelo chama a ferramenta de histórico, encontra a conversa anterior,
// e responde: "Sua cor favorita é azul."

# Em uma nova sessão, o modelo pode recuperar conversas anteriores
result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Qual é a minha cor favorita?",
    tools=[{"type": "history"}],
    store=True,
)

# O modelo chama a ferramenta de histórico, encontra a conversa anterior,
# e responde: "Sua cor favorita é azul."

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": "Qual é a minha cor favorita?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Exemplo completo: armazenar e recuperar entre sessões

Este exemplo mostra o fluxo completo — armazenar informações em uma solicitação e recuperá-las em uma solicitação separada.

# Sessão 1: Diga ao modelo algo para lembrar
mka1 llm responses create \
  --model meetkai:functionary-pt \
  --body '{
    "input": "Lembre-se disto: o prazo do projeto é 15 de março e o orçamento é $50,000.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

# Sessão 2: Pergunte sobre isso mais tarde
mka1 llm responses create \
  --model meetkai:functionary-pt \
  --body '{
    "input": "Qual é o prazo e o orçamento do projeto?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

import { SDK } from '@meetkai/mka1';
import type { ResponseObject } from '@meetkai/mka1/models/components';

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

// Sessão 1: Diga ao modelo algo para lembrar
const first = await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Lembre-se disto: o prazo do projeto é 15 de março e o orçamento é $50,000.',
    tools: [{ type: 'history' }],
    store: true,
  },
}) as ResponseObject;

console.log('Armazenado:', first.outputText);

// Sessão 2: Pergunte sobre isso mais tarde
const second = await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Qual é o prazo e o orçamento do projeto?',
    tools: [{ type: 'history' }],
    store: true,
  },
}) as ResponseObject;

console.log('Recuperado:', second.outputText);
// → "O prazo do projeto é 15 de março e o orçamento é $50,000."

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': 'user-123' },
});

// Sessão 1: Diga ao modelo algo para lembrar
const first = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Lembre-se disto: o prazo do projeto é 15 de março e o orçamento é $50,000.',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

console.log('Armazenado:', first.output_text);

// Sessão 2: Pergunte sobre isso mais tarde
const second = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Qual é o prazo e o orçamento do projeto?',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

console.log('Recuperado:', second.output_text);
// → "O prazo do projeto é 15 de março e o orçamento é $50,000."

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

var sdk = new SDK(
    bearerAuth: $"Bearer {YOUR_API_KEY}",
    serverUrl: "https://apigw.mka1.com"
);

var historyTools = new List<ResponsesCreateRequestTool>
{
    ResponsesCreateRequestTool.CreateHistoryToolDefinition(new HistoryToolDefinition()),
};

// Sessão 1: Diga ao modelo algo para lembrar
var first = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Lembre-se disto: o prazo do projeto é 15 de março e o orçamento é $50,000."),
    Tools = historyTools,
    Store = true,
});

Console.WriteLine($"Armazenado: {first.OutputText}");

// Sessão 2: Pergunte sobre isso mais tarde
var second = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Qual é o prazo e o orçamento do projeto?"),
    Tools = historyTools,
    Store = true,
});

Console.WriteLine($"Recuperado: {second.OutputText}");
// -> "O prazo do projeto é 15 de março e o orçamento é $50,000."

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

# Sessão 1: Diga ao modelo algo para lembrar
first = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Lembre-se disto: o prazo do projeto é 15 de março e o orçamento é $50,000.",
    tools=[{"type": "history"}],
    store=True,
)

print("Armazenado:", first.output_text)

# Sessão 2: Pergunte sobre isso mais tarde
second = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Qual é o prazo e o orçamento do projeto?",
    tools=[{"type": "history"}],
    store=True,
)

print("Recuperado:", second.output_text)
# -> "O prazo do projeto é 15 de março e o orçamento é $50,000."

# Sessão 1: Armazene informações
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: user-123' \
  --data '{
    "model": "meetkai:functionary-pt",
    "input": "Lembre-se disto: o prazo do projeto é 15 de março e o orçamento é $50,000.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

# Sessão 2: Recupere as informações mais tarde
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: user-123' \
  --data '{
    "model": "meetkai:functionary-pt",
    "input": "Qual é o prazo e o orçamento do projeto?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Detalhes do comportamento

Aspecto	Detalhe
Armazenamento	Automático — cada par de solicitação e resposta é indexado após a conclusão da resposta
Pesquisa	Semântica — usa embeddings vetoriais, não correspondência por palavras-chave
Escopo	Por usuário final — isolado pelo cabeçalho `X-On-Behalf-Of`
Indexação	Em segundo plano — não adiciona latência à resposta
Resultados	Até 10 interações anteriores mais relevantes retornadas por pesquisa
Tamanho da entrada	Texto truncado para 7.500 caracteres por entrada para embedding

Quando usar a ferramenta de histórico

Personalização: Lembre-se de preferências, nomes ou contexto do usuário entre sessões
Continuidade do projeto: Recupere decisões, prazos ou requisitos discutidos anteriormente
Fluxos de trabalho de suporte: Mantenha o contexto sobre o histórico de problemas de um usuário
Assistentes: Crie assistentes que aprendem e se adaptam a usuários individuais ao longo do tempo

Próximas etapas

Conversas — gerencie trocas de múltiplos turnos em uma única sessão
Arquivos e armazenamentos vetoriais — armazene e pesquise documentos
Gerar uma resposta — solicitações de texto e trocas de múltiplos turnos

⌘I

Primeiros passos

Respostas

Recursos

Computação

CLI

Receitas

Benchmarks

Infraestrutura

Memória de longo prazo

Como funciona

Ativar a ferramenta de histórico

Recuperar informações de uma sessão anterior

Exemplo completo: armazenar e recuperar entre sessões

Detalhes do comportamento

Quando usar a ferramenta de histórico

Próximas etapas

​Como funciona

​Ativar a ferramenta de histórico

​Recuperar informações de uma sessão anterior

​Exemplo completo: armazenar e recuperar entre sessões

​Detalhes do comportamento

​Quando usar a ferramenta de histórico

​Próximas etapas

Como funciona

Ativar a ferramenta de histórico

Recuperar informações de uma sessão anterior

Exemplo completo: armazenar e recuperar entre sessões

Detalhes do comportamento

Quando usar a ferramenta de histórico

Próximas etapas