Memoria a largo plazo

La herramienta history otorga a los modelos memoria a largo plazo que persiste entre sesiones. Cuando está habilitada, cada par de solicitud-respuesta se almacena e indexa automáticamente. El modelo puede luego buscar semánticamente en interacciones pasadas para recordar información de conversaciones anteriores.

Cómo funciona

Agrega { type: "history" } al array tools en tu solicitud
El modelo recibe una función history que puede llamar con una consulta de búsqueda
Las conversaciones pasadas se buscan usando incrustaciones vectoriales para similitud semántica
Después de cada respuesta, el mensaje del usuario y la respuesta del asistente se almacenan automáticamente en segundo plano

La memoria está delimitada por usuario final — cada ID de usuario X-On-Behalf-Of obtiene un historial aislado. Diferentes usuarios finales no pueden ver el historial de otros.

Habilitar la herramienta de historial

mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --body '{
    "input": "Recuerda esto: mi color favorito es 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({
  model: 'meetkai:functionary-es-mini',
  input: 'Recuerda esto: mi color favorito es azul.',
  tools: [{ type: 'history' }],
  store: true,
}, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

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: 'Recuerda esto: mi color favorito es 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-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Recuerda esto: mi color favorito es azul."),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateHistoryToolDefinition(new HistoryToolDefinition()),
    },
    Store = true,
});

from mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Recuerda esto: mi color favorito es 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-es-mini",
    "input": "Recuerda esto: mi color favorito es azul.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Establece store: true para que la conversación se persista y esté disponible para futuras consultas.

Recordar información de una sesión anterior

En una solicitud posterior — incluso minutos, horas o días después — el modelo puede buscar en su historial para encontrar interacciones pasadas relevantes. El modelo decide cuándo llamar a la herramienta de historial según la pregunta del usuario.

mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --body '{
    "input": "¿Cuál es mi color favorito?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

// En una nueva sesión, el modelo puede recordar conversaciones pasadas
const result = await mka1.llm.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: '¿Cuál es mi color favorito?',
  tools: [{ type: 'history' }],
  store: true,
}, { headers: { 'X-On-Behalf-Of': '<end-user-id>' } });

// El modelo llama a la herramienta de historial, encuentra la conversación anterior,
// y responde: "Tu color favorito es azul."

const response = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: '¿Cuál es mi color favorito?',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

// El modelo llama a la herramienta de historial, encuentra la conversación anterior,
// y responde: "Tu color favorito es azul."

// En una nueva sesión, el modelo puede recordar conversaciones pasadas
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr("¿Cuál es mi color favorito?"),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateHistoryToolDefinition(new HistoryToolDefinition()),
    },
    Store = true,
});

// El modelo llama a la herramienta de historial, encuentra la conversación anterior,
// y responde: "Tu color favorito es azul."

# En una nueva sesión, el modelo puede recordar conversaciones pasadas
result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="¿Cuál es mi color favorito?",
    tools=[{"type": "history"}],
    store=True,
)

# El modelo llama a la herramienta de historial, encuentra la conversación anterior,
# y responde: "Tu color favorito es 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-es-mini",
    "input": "¿Cuál es mi color favorito?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Ejemplo completo: almacenar y recuperar entre sesiones

Este ejemplo muestra el flujo completo — almacenar información en una solicitud y recuperarla en una solicitud separada.

# Sesión 1: Dile al modelo algo para recordar
mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --body '{
    "input": "Recuerda esto: la fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

# Sesión 2: Pregunta sobre ello después
mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --body '{
    "input": "¿Cuál es la fecha límite del proyecto y el presupuesto?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

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

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

const headers = { 'X-On-Behalf-Of': 'user-123' };

// Sesión 1: Dile al modelo algo para recordar
const first = await mka1.llm.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: 'Recuerda esto: la fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000.',
  tools: [{ type: 'history' }],
  store: true,
}, { headers });

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

// Sesión 2: Pregunta sobre ello después
const second = await mka1.llm.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: '¿Cuál es la fecha límite del proyecto y el presupuesto?',
  tools: [{ type: 'history' }],
  store: true,
}, { headers });

console.log('Recuperado:', second.outputText);
// → "La fecha límite del proyecto es el 15 de marzo y el presupuesto es de $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' },
});

// Sesión 1: Dile al modelo algo para recordar
const first = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: 'Recuerda esto: la fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000.',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

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

// Sesión 2: Pregunta sobre ello después
const second = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: '¿Cuál es la fecha límite del proyecto y el presupuesto?',
  tools: [{ type: 'history' }],
  store: true,
  stream: false,
});

console.log('Recuperado:', second.output_text);
// → "La fecha límite del proyecto es el 15 de marzo y el presupuesto es de $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()),
};

// Sesión 1: Dile al modelo algo para recordar
var first = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Recuerda esto: la fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000."),
    Tools = historyTools,
    Store = true,
});

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

// Sesión 2: Pregunta sobre ello después
var second = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr(
        "¿Cuál es la fecha límite del proyecto y el presupuesto?"),
    Tools = historyTools,
    Store = true,
});

Console.WriteLine($"Recuperado: {second.OutputText}");
// -> "La fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000."

from mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

# Sesión 1: Dile al modelo algo para recordar
first = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Recuerda esto: la fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000.",
    tools=[{"type": "history"}],
    store=True,
)

print("Almacenado:", first.output_text)

# Sesión 2: Pregunta sobre ello después
second = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="¿Cuál es la fecha límite del proyecto y el presupuesto?",
    tools=[{"type": "history"}],
    store=True,
)

print("Recuperado:", second.output_text)
# -> "La fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000."

# Sesión 1: Almacenar información
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-es-mini",
    "input": "Recuerda esto: la fecha límite del proyecto es el 15 de marzo y el presupuesto es de $50,000.",
    "tools": [{ "type": "history" }],
    "store": true
  }'

# Sesión 2: Recuperar después
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-es-mini",
    "input": "¿Cuál es la fecha límite del proyecto y el presupuesto?",
    "tools": [{ "type": "history" }],
    "store": true
  }'

Detalles del comportamiento

Aspecto	Detalle
Almacenamiento	Automático — cada par solicitud/respuesta se indexa después de la respuesta
Búsqueda	Semántica — usa incrustaciones vectoriales, no coincidencia por palabras clave
Alcance	Por usuario final — aislado por el encabezado `X-On-Behalf-Of`
Indexación	En segundo plano — no añade latencia a la respuesta
Resultados	Hasta 10 interacciones pasadas más relevantes devueltas por búsqueda
Tamaño de entrada	El texto se trunca a 7,500 caracteres por entrada para incrustación

Cuándo usar la herramienta de historial

Personalización: Recordar preferencias del usuario, nombres o contexto entre sesiones
Continuidad de proyectos: Recordar decisiones, fechas límite o requisitos discutidos previamente
Flujos de soporte: Mantener contexto sobre el historial de incidencias de un usuario
Asistentes: Construir asistentes que aprendan y se adapten a usuarios individuales con el tiempo

Próximos pasos

Conversaciones — gestiona intercambios de varios turnos dentro de una sola sesión
Archivos y almacenes vectoriales — almacena y busca documentos
Generar una respuesta — solicitudes de texto e intercambios de varios turnos

​Cómo funciona

​Habilitar la herramienta de historial

​Recordar información de una sesión anterior

​Ejemplo completo: almacenar y recuperar entre sesiones

​Detalles del comportamiento

​Cuándo usar la herramienta de historial

​Próximos pasos