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

# Memoria a largo plazo

> Utiliza la herramienta de historial para dar a los modelos memoria persistente entre sesiones, permitiendo recordar conversaciones pasadas por usuario final.

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

1. Agrega `{ type: "history" }` al array `tools` en tu solicitud
2. El modelo recibe una función `history` que puede llamar con una consulta de búsqueda
3. Las conversaciones pasadas se buscan usando incrustaciones vectoriales para similitud semántica
4. 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

<CodeGroup>
  ```bash CLI theme={null}
  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>'
  ```

  ```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-es-mini',
    input: 'Recuerda esto: mi color favorito es azul.',
    tools: [{ type: 'history' }],
    store: true,
  }, { 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-es-mini',
    input: 'Recuerda esto: mi color favorito es azul.',
    tools: [{ type: 'history' }],
    store: true,
    stream: false,
  });
  ```

  ```csharp C# SDK theme={null}
  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,
  });
  ```

  ```python Python SDK theme={null}
  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,
  )
  ```

  ```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-es-mini",
      "input": "Recuerda esto: mi color favorito es azul.",
      "tools": [{ "type": "history" }],
      "store": true
    }'
  ```
</CodeGroup>

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.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --body '{
      "input": "¿Cuál es mi color favorito?",
      "tools": [{ "type": "history" }],
      "store": true
    }'
  ```

  ```ts MKA1 SDK theme={null}
  // 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."
  ```

  ```ts OpenAI SDK theme={null}
  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."
  ```

  ```csharp C# SDK theme={null}
  // 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."
  ```

  ```python Python SDK theme={null}
  # 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."
  ```

  ```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-es-mini",
      "input": "¿Cuál es mi color favorito?",
      "tools": [{ "type": "history" }],
      "store": true
    }'
  ```
</CodeGroup>

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

<CodeGroup>
  ```bash CLI theme={null}
  # 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
    }'
  ```

  ```ts MKA1 SDK theme={null}
  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."
  ```

  ```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': '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."
  ```

  ```csharp C# SDK theme={null}
  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."
  ```

  ```python Python SDK theme={null}
  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."
  ```

  ```bash bash theme={null}
  # 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
    }'
  ```
</CodeGroup>

## 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](/es/docs/conversations) — gestiona intercambios de varios turnos dentro de una sola sesión
* [Archivos y almacenes vectoriales](/es/docs/files-and-vector-stores) — almacena y busca documentos
* [Generar una respuesta](/es/docs/generate-a-response) — solicitudes de texto e intercambios de varios turnos