Loading...
    • Construir
    • Administración
    • Modelos y precios
    • SDKs de cliente
    • Referencia de la API
    Search...
    ⌘K
    Primeros pasos
    Introducción a ClaudeInicio rápido
    Construir con Claude
    Descripción general de funcionesUsar la API de mensajesGestionar razones de parada
    Capacidades del modelo
    Pensamiento extendidoPensamiento adaptativoEsfuerzoModo rápido (beta: vista previa de investigación)Salidas estructuradasCitasMensajes en streamingProcesamiento por lotesResultados de búsquedaRechazos en streamingSoporte multilingüeEmbeddings
    Herramientas
    Descripción generalCómo funciona el uso de herramientasHerramienta de búsqueda webHerramienta de recuperación webHerramienta de ejecución de códigoHerramienta de memoriaHerramienta BashHerramienta de uso del ordenadorHerramienta de edición de texto
    Infraestructura de herramientas
    Búsqueda de herramientasLlamada programática de herramientasStreaming detallado de herramientas
    Gestión del contexto
    Ventanas de contextoCompactaciónEdición de contextoCaché de promptsConteo de tokens
    Trabajar con archivos
    Files APISoporte de PDFImágenes y visión
    Skills
    Descripción generalInicio rápidoMejores prácticasSkills para empresasSkills en la API
    MCP
    Servidores MCP remotosConector MCP
    Ingeniería de prompts
    Descripción generalMejores prácticas de promptsHerramientas de prompts en Console
    Probar y evaluar
    Definir el éxito y crear evaluacionesUsar la herramienta de evaluación en ConsoleReducir la latencia
    Reforzar las barreras de seguridad
    Reducir alucinacionesAumentar la consistencia de salidaMitigar jailbreaksReducir la filtración de prompts
    Recursos
    Glosario
    Notas de versión
    Claude Platform
    Console
    Log in
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...

    Solutions

    • AI agents
    • Code modernization
    • Coding
    • Customer support
    • Education
    • Financial services
    • Government
    • Life sciences

    Partners

    • Amazon Bedrock
    • Google Cloud's Vertex AI

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Company

    • Anthropic
    • Careers
    • Economic Futures
    • Research
    • News
    • Responsible Scaling Policy
    • Security and compliance
    • Transparency

    Learn

    • Blog
    • Catalog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Help and security

    • Availability
    • Status
    • Support
    • Discord

    Terms and policies

    • Privacy policy
    • Responsible disclosure policy
    • Terms of service: Commercial
    • Terms of service: Consumer
    • Usage policy
    Delegar trabajo a tu agente

    Usar memoria

    Dale a tus agentes memoria persistente que sobreviva entre sesiones usando almacenes de memoria.

    Was this page helpful?

    • Descripción general
    • Crear un almacén de memoria
    • Sembrarlo con contenido (opcional)
    • Adjuntar memoria a una sesión
    • Herramientas de memoria
    • Inspeccionar y corregir memoria
    • Listar memorias
    • Leer una memoria
    • Escribir un documento
    • Crear solo si la ruta está libre
    • Actualizar
    • Eliminar un documento
    • Versiones de memoria
    • Listar versiones
    • Recuperar una versión
    • Redactar una versión

    Agent Memory es una función de Research Preview. Solicita acceso para probarla.

    Las sesiones de la API de Managed Agents son efímeras por defecto. Cuando una sesión termina, todo lo que el agente aprendió desaparece. Los almacenes de memoria permiten que el agente lleve sus aprendizajes entre sesiones: preferencias del usuario, convenciones de proyectos, errores anteriores y contexto del dominio.

    Todas las solicitudes de la API de Managed Agents requieren el encabezado beta managed-agents-2026-04-01. Se necesita un encabezado beta adicional para funciones de research preview. El SDK establece estos encabezados beta automáticamente.

    Descripción general

    Un almacén de memoria es una colección de documentos de texto con alcance de espacio de trabajo optimizada para Claude. Cuando uno o más almacenes de memoria se adjuntan a una sesión, el agente verifica automáticamente los almacenes antes de comenzar una tarea y escribe aprendizajes duraderos cuando termina - no se necesita solicitud o configuración adicional de tu parte.

    Cada memoria en un almacén puede ser accedida y editada directamente a través de la API o Console, permitiendo ajustes, importación y exportación de memorias.

    Cada cambio a una memoria crea una memory_version inmutable para soportar auditoría y reversión de cambios de memoria.

    Crear un almacén de memoria

    Dale al almacén un name y una description. La descripción se pasa al agente, diciéndole qué contiene el almacén.

    store=$(curl -fsS https://api.anthropic.com/v1/memory_stores \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      --data @- <<EOF
    {
      "name": "User Preferences",
      "description": "Per-user preferences and project context."
    }
    EOF
    )
    store_id=$(jq -r '.id' <<< "$store")
    echo "$store_id"  # memstore_01Hx...

    El id del almacén de memoria (memstore_...) es lo que pasas al adjuntar el almacén a una sesión.

    Sembrarlo con contenido (opcional)

    Precarga un almacén con material de referencia antes de que se ejecute cualquier agente:

    Las memorias individuales dentro del almacén están limitadas a 100KB (~25K tokens). Estructura la memoria como muchos archivos pequeños y enfocados, no unos pocos grandes.

    Adjuntar memoria a una sesión

    Los almacenes de memoria se adjuntan en el array resources[] de la sesión.

    Opcionalmente incluye un prompt si deseas proporcionar instrucciones específicas de la sesión a Claude sobre cómo usar este almacén de memoria. Se proporciona a Claude además del name y description del almacén de memoria, y está limitado a 4.096 caracteres.

    También puedes configurar access. Por defecto es read_write, pero también se soporta read_only (mostrado explícitamente en el ejemplo a continuación).

    Se soporta un máximo de 8 almacenes de memoria por sesión. Adjunta múltiples almacenes cuando diferentes partes de la memoria tienen diferentes propietarios o reglas de acceso. Razones comunes:

    • Material de referencia compartido - un almacén de solo lectura adjunto a muchas sesiones (estándares, convenciones, conocimiento del dominio), mantenido separado de los aprendizajes de lectura-escritura propios de cada sesión.
    • Mapeo a la estructura de tu producto - un almacén por usuario final, por equipo o por proyecto, mientras se comparte una única configuración de agente.
    • Ciclos de vida diferentes - un almacén que sobrevive a cualquier sesión individual, o uno que deseas archivar en tu propio cronograma.

    Herramientas de memoria

    Cuando los almacenes de memoria se adjuntan a una sesión, el agente obtiene automáticamente acceso a herramientas de memoria. Las interacciones del agente con almacenes de memoria se registran como eventos agent.tool_use en el flujo de eventos.

    HerramientaDescripción
    memory_listListar documentos en un almacén, opcionalmente filtrados por prefijo de ruta.
    memory_searchBúsqueda de texto completo en los contenidos de documentos.
    memory_readLeer el contenido de un documento.
    memory_writeCrear o sobrescribir un documento en una ruta.
    memory_editModificar un documento existente.
    memory_deleteEliminar un documento.

    Inspeccionar y corregir memoria

    Los almacenes de memoria pueden ser gestionados directamente a través de la API. Úsalo para construir flujos de trabajo de revisión, corregir memorias incorrectas, o sembrar almacenes antes de que se ejecute cualquier sesión.

    Listar memorias

    List no devuelve contenido de memoria, solo metadatos de objetos. Usa path_prefix para listas con alcance de directorio (incluye una barra diagonal final: /notes/ coincide con /notes/a.md pero no con /notes_backup/old.md).

    Leer una memoria

    Obtener una memoria individual devuelve el contenido completo del documento.

    Escribir un documento

    Usa memories.write para hacer upsert de un documento por ruta. Si nada existe en la ruta, se crea; si un documento ya existe allí, su contenido se reemplaza. Para mutar un documento existente por mem_... ID (por ejemplo, para renombrar su ruta o aplicar de forma segura una edición de contenido), usa memories.update en su lugar (ver Update a continuación).

    Crear solo si la ruta está libre

    Pasa precondition={"type": "not_exists"} a memories.write para hacerlo una protección de solo creación. Si un documento ya existe en la ruta, la escritura devuelve 409 memory_precondition_failed en lugar de reemplazarlo. Úsalo cuando estés sembrando un almacén y desees evitar sobrescribir contenido existente.

    Para editar de forma segura un documento existente (leer, modificar, escribir de vuelta sin sobrescribir un cambio concurrente), usa memories.update con una precondición content_sha256 en su lugar. Ver Update a continuación.

    Actualizar

    memories.update() modifica un documento existente por su mem_... ID. Puedes cambiar content, path (un renombre), o ambos en una sola llamada.

    Renombrar a una ruta ocupada devuelve 409 conflict. El llamador debe eliminar o renombrar el bloqueador primero, o pasar precondition={"type": "not_exists"} para hacer que el renombre sea una no-op si algo ya existe en el destino.

    El ejemplo a continuación renombra un documento a una ruta de archivo:

    Ediciones de contenido seguras (concurrencia optimista)

    Para editar el contenido de un documento sin sobrescribir una escritura concurrente, pasa una precondición content_sha256. La actualización solo se aplica si el hash almacenado aún coincide con el que leíste; en caso de desajuste devuelve 409 memory_precondition_failed, en cuyo punto relees el documento e intentas de nuevo contra el estado fresco.

    Eliminar un documento

    Opcionalmente pasa expected_content_sha256 para una eliminación condicional.

    Versiones de memoria

    Cada mutación a una memoria crea una memory version inmutable (memver_...). Las versiones se acumulan durante la vida útil de la memoria padre y forman la superficie de auditoría y reversión debajo de ella. La llamada memories.retrieve en vivo siempre devuelve el head actual; los endpoints de versión te dan el historial completo.

    Se escribe una nueva versión en cada mutación:

    • El primer memories.write a una ruta crea una versión con operation: "created".
    • memories.update que cambia content, path, o ambos crea una versión con operation: "modified".
    • memories.delete crea una versión con operation: "deleted".

    Usa los endpoints de versión para auditar qué usuario o agente cambió qué y cuándo, para inspeccionar o restaurar una instantánea anterior, y para eliminar contenido sensible del historial con redact.

    Listar versiones

    Listar metadatos de versión paginados para una tienda, más recientes primero. Filtrar por memory_id, operation (created, modified, o deleted), session_id, api_key_id, o un rango de tiempo created_at_gte/created_at_lte. La respuesta de lista no incluye el cuerpo content; obtén versiones individuales con retrieve cuando necesites el contenido completo.

    Recuperar una versión

    Obtener una versión individual devuelve los mismos campos que la respuesta de lista más el cuerpo content completo.

    Redactar una versión

    Redactar limpia el contenido de una versión histórica mientras se preserva el registro de auditoría (quién hizo qué, cuándo). Úsalo para flujos de trabajo de cumplimiento normativo como eliminar secretos filtrados, información de identificación personal, o solicitudes de eliminación de usuarios. Redactar borra completamente content, content_sha256, content_size_bytes, y path; todos los demás campos, incluyendo el actor y las marcas de tiempo, se preservan.

    curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      --data @- > /dev/null <<EOF
    {
      "path": "/formatting_standards.md",
      "content": "All reports use GAAP formatting. Dates are ISO-8601..."
    }
    EOF
    session=$(curl -fsS https://api.anthropic.com/v1/sessions \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      --data @- <<EOF
    {
      "agent": "$agent_id",
      "environment_id": "$environment_id",
      "resources": [
        {
          "type": "memory_store",
          "memory_store_id": "$store_id",
          "access": "read_write",
          "prompt": "User preferences and project context. Check before starting any task."
        }
      ]
    }
    EOF
    )
    page=$(curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memories?path_prefix=/" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01")
    jq -r '.data[] | "\(.path)  (\(.size_bytes) bytes, sha=\(.content_sha256[0:8]))"' <<< "$page"
    mem=$(curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$memory_id" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01")
    jq -r '.content' <<< "$mem"
    mem=$(curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      --data @- <<EOF
    {
      "path": "/preferences/formatting.md",
      "content": "Always use tabs, not spaces."
    }
    EOF
    )
    curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      --data @- > /dev/null <<EOF
    {
      "path": "/preferences/formatting.md",
      "content": "Always use 2-space indentation.",
      "precondition": {"type": "not_exists"}
    }
    EOF
    curl -fsS -X PATCH "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      -d '{"path": "/archive/2026_q1_formatting.md"}' > /dev/null
    curl -fsS -X PATCH "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      --data @- > /dev/null <<EOF
    {
      "content": "CORRECTED: Always use 2-space indentation.",
      "precondition": {"type": "content_sha256", "content_sha256": "$mem_sha"}
    }
    EOF
    curl -fsS -X DELETE "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" > /dev/null
    curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions?memory_id=$mem_id" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      | jq -r '.data[] | "\(.id): \(.operation)"'
    curl -fsS "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions/$version_id" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01"
    curl -fsS -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions/$version_id/redact" \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: managed-agents-2026-04-01" \
      -H "content-type: application/json" \
      -d '{}'