Long-term memory

The history tool gives models long-term memory that persists across sessions. When enabled, every request-response pair is automatically stored and indexed. The model can then semantically search past interactions to recall information from earlier conversations.

How it works

Add { type: "history" } to the tools array in your request
The model receives a history function it can call with a search query
Past conversations are searched using vector embeddings for semantic similarity
After each response completes, the user message and assistant reply are stored automatically in the background

Memory is scoped per end-user — each X-On-Behalf-Of user ID gets an isolated history store. Different end-users cannot see each other’s history.

Enable the history tool

mka1 llm responses create \
  --model auto \
  --body '{
    "input": "Remember this: my favorite color is blue.",
    "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>', // optional — attribute the request to one of your end users
  responsesCreateRequest: {
    model: 'auto',
    input: 'Remember this: my favorite color is blue.',
    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: 'auto',
  input: 'Remember this: my favorite color is blue.',
  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 = "auto",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Remember this: my favorite color is blue."),
    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="auto",
    input="Remember this: my favorite color is blue.",
    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": "auto",
    "input": "Remember this: my favorite color is blue.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Set store: true so the conversation is persisted and available for future recall.

Recall information from a previous session

In a later request — even minutes, hours, or days later — the model can search its history to find relevant past interactions. The model decides when to call the history tool based on the user’s question.

mka1 llm responses create \
  --model auto \
  --body '{
    "input": "What is my favorite color?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

// In a new session, the model can recall past conversations
const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'auto',
    input: 'What is my favorite color?',
    tools: [{ type: 'history' }],
    store: true,
  },
});

// The model calls the history tool, finds the earlier conversation,
// and responds: "Your favorite color is blue."

const response = await openai.responses.create({
  model: 'auto',
  input: 'What is my favorite color?',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

// The model calls the history tool, finds the earlier conversation,
// and responds: "Your favorite color is blue."

// In a new session, the model can recall past conversations
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "auto",
    Input = ResponsesCreateRequestInput.CreateStr("What is my favorite color?"),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateHistoryToolDefinition(new HistoryToolDefinition()),
    },
    Store = true,
});

// The model calls the history tool, finds the earlier conversation,
// and responds: "Your favorite color is blue."

# In a new session, the model can recall past conversations
result = sdk.llm.responses.create(
    model="auto",
    input="What is my favorite color?",
    tools=[{"type": "history"}],
    store=True,
)

# The model calls the history tool, finds the earlier conversation,
# and responds: "Your favorite color is blue."

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": "auto",
    "input": "What is my favorite color?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Full example: store and retrieve across sessions

This example shows the complete flow — storing information in one request and retrieving it in a separate request.

# Session 1: Tell the model something to remember
mka1 llm responses create \
  --model auto \
  --body '{
    "input": "Remember this: the project deadline is March 15th and the budget is $50,000.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

# Session 2: Ask about it later
mka1 llm responses create \
  --model auto \
  --body '{
    "input": "What is the project deadline and budget?",
    "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}`,
});

// Session 1: Tell the model something to remember
const first = await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'auto',
    input: 'Remember this: the project deadline is March 15th and the budget is $50,000.',
    tools: [{ type: 'history' }],
    store: true,
  },
}) as ResponseObject;

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

// Session 2: Ask about it later
const second = await mka1.llm.responses.create({
  xOnBehalfOf: 'user-123',
  responsesCreateRequest: {
    model: 'auto',
    input: 'What is the project deadline and budget?',
    tools: [{ type: 'history' }],
    store: true,
  },
}) as ResponseObject;

console.log('Recalled:', second.outputText);
// → "The project deadline is March 15th and the budget is $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' },
});

// Session 1: Tell the model something to remember
const first = await openai.responses.create({
  model: 'auto',
  input: 'Remember this: the project deadline is March 15th and the budget is $50,000.',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

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

// Session 2: Ask about it later
const second = await openai.responses.create({
  model: 'auto',
  input: 'What is the project deadline and budget?',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

console.log('Recalled:', second.output_text);
// → "The project deadline is March 15th and the budget is $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()),
};

// Session 1: Tell the model something to remember
var first = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "auto",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Remember this: the project deadline is March 15th and the budget is $50,000."),
    Tools = historyTools,
    Store = true,
});

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

// Session 2: Ask about it later
var second = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "auto",
    Input = ResponsesCreateRequestInput.CreateStr(
        "What is the project deadline and budget?"),
    Tools = historyTools,
    Store = true,
});

Console.WriteLine($"Recalled: {second.OutputText}");
// -> "The project deadline is March 15th and the budget is $50,000."

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

# Session 1: Tell the model something to remember
first = sdk.llm.responses.create(
    model="auto",
    input="Remember this: the project deadline is March 15th and the budget is $50,000.",
    tools=[{"type": "history"}],
    store=True,
)

print("Stored:", first.output_text)

# Session 2: Ask about it later
second = sdk.llm.responses.create(
    model="auto",
    input="What is the project deadline and budget?",
    tools=[{"type": "history"}],
    store=True,
)

print("Recalled:", second.output_text)
# -> "The project deadline is March 15th and the budget is $50,000."

# Session 1: Store information
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": "auto",
    "input": "Remember this: the project deadline is March 15th and the budget is $50,000.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

# Session 2: Retrieve it later
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": "auto",
    "input": "What is the project deadline and budget?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Behavior details

Aspect	Detail
Storage	Automatic — each request/response pair is indexed after the response completes
Search	Semantic — uses vector embeddings, not keyword matching
Scope	Per end-user — isolated by `X-On-Behalf-Of` header
Indexing	Background — does not add latency to the response
Results	Up to 10 most relevant past interactions returned per search
Entry size	Text truncated to 7,500 characters per entry for embedding

When to use the history tool

Personalization: Remember user preferences, names, or context across sessions
Project continuity: Recall decisions, deadlines, or requirements discussed earlier
Support workflows: Maintain context about a user’s issue history
Assistants: Build assistants that learn and adapt to individual users over time

Next steps

Conversations — manage multi-turn exchanges within a single session
Files and vector stores — store and search documents
Generate a response — text requests and multi-turn exchanges

Getting started

Responses

Features

Compute

CLI

Recipes

Benchmarks

Infrastructure

Long-term memory

How it works

Enable the history tool

Recall information from a previous session

Full example: store and retrieve across sessions

Behavior details

When to use the history tool

Next steps

​How it works

​Enable the history tool

​Recall information from a previous session

​Full example: store and retrieve across sessions

​Behavior details

​When to use the history tool

​Next steps

How it works

Enable the history tool

Recall information from a previous session

Full example: store and retrieve across sessions

Behavior details

When to use the history tool

Next steps