Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Metadata terstruktur untuk memori jangka panjang

Pemfilteran metadata di Amazon Bedrock AgentCore Memory memungkinkan Anda menambahkan atribut terstruktur ke catatan memori jangka panjang Anda. Anda dapat menggunakan atribut tersebut untuk mempersempit catatan mana yang dikembalikan selama pengambilan. Ruang nama sudah mengisolasi memori oleh entitas utama (pengguna, penyewa, pasien, klien). Namun, dalam satu namespace, pencarian semantik yang luas mengembalikan semua yang memiliki makna yang dekat. Dengan pemfilteran metadata, Anda hanya dapat mengambil hasil yang cocok dengan nilai atribut tertentu. Misalnya, Anda hanya dapat mengambil catatan prioritas tinggi, hanya catatan dari departemen tertentu, atau hanya catatan yang dibuat dalam rentang waktu tertentu.

Dengan pemfilteran metadata, Anda dapat:

Memulai

Menyiapkan pemfilteran metadata melibatkan lima langkah:

Bagian selanjutnya berjalan melalui setiap langkah secara rinci.

Konsep Utama

Kunci metadata yang diindeks

Kunci yang diindeks dideklarasikan pada tingkat sumber daya memori di CreateMemory (atau ditambahkan nanti melaluiUpdateMemory). Kunci terindeks disimpan dalam format yang dioptimalkan untuk pemfilteran kueri cepat. Hanya kunci yang diindeks yang dapat dikueri di metadataFilters on ListMemoryRecords dan. RetrieveMemoryRecords

Contoh berikut menyatakan dua kunci yang diindeks:

{
  "indexedKeys": [
    { "key": "priority", "type": "STRING" },
    { "key": "tags",     "type": "STRINGLIST" }
  ]
}

Nilai type yang didukung:STRING,STRINGLIST,NUMBER.

Tombol harus cocok ^[a-zA-Z0-9\s._:/=+@-]*$ (maks 128 karakter).

Menambahkan kunci yang diindeks tidak mengisi ulang catatan yang ada. Hanya catatan yang dibuat atau diperbarui setelah kunci dideklarasikan yang diindeks untuk kunci tersebut. Untuk detail selengkapnya tentang mengembangkan skema Anda dari waktu ke waktu, lihatLangkah 5: Kembangkan skema metadata Anda.

Skema metadata (per strategi)

Strategi Memori secara opsional dapat memiliki skema metadata yang di deklarasikan dimemoryRecordSchema.metadataSchema. Skema metadata memberi tahu LLM metadata apa yang harus diekstrak dari konten percakapan saat menghasilkan catatan memori. Hanya kunci yang ditentukan dalam skema metadata strategi yang diisi pada catatan memori yang dihasilkan selama ekstraksi berbasis peristiwa.

Setiap entri dalam skema mendefinisikan:

Contoh berikut menunjukkan entri skema metadata dengan validasi:

{
  "metadataSchema": [
    {
      "key": "priority",
      "type": "STRING",
      "extractionConfig": {
        "llmExtractionConfig": {
          "definition": "Issue priority level based on customer impact. Values range from critical (most severe) to low (least severe).",
          "llmExtractionInstruction": "LATEST_VALUE",
          "validation": {
            "stringValidation": {
              "allowedValues": ["critical", "high", "medium", "low"]
            }
          }
        }
      }
    }
  ]
}

Opsi validasi berdasarkan jenis:

Metadata deterministik (tipe ekstraksi STRICTLY_CONSISTANT)

Kunci metadata deterministik berisi nilai yang sudah diketahui aplikasi Anda saat membuat acara. Nilai-nilai ini disalin tepat ke catatan memori yang dihasilkan tanpa modifikasi. Pengklasifikasi organisasi sepertidepartment,compliance_level, atau tidak agent_id boleh disimpulkan oleh LLM. Inferensi LLM memperkenalkan variabilitas. Misalnya, percakapan yang sama dapat dihasilkan "eng" pada satu catatan dan "Engineering" pada yang lain.

Untuk kunci ini, atur extractionType ke STRICTLY_CONSISTENT dalam entri skema metadata. Nilai yang diberikan pada acara menyebar tidak berubah melalui ekstraksi dan konsolidasi. LLM tidak dikonsultasikan untuk kunci itu.

JSON berikut menunjukkan skema metadata dengan kedua STRICTLY_CONSISTENT dan jenis LLM_INFERRED ekstraksi:

{
  "metadataSchema": [
    {
      "key": "department",
      "type": "STRING",
      "extractionType": "STRICTLY_CONSISTENT"
    },
    {
      "key": "compliance_level",
      "type": "STRING",
      "extractionType": "STRICTLY_CONSISTENT"
    },
    {
      "key": "topic",
      "type": "STRING",
      "extractionType": "LLM_INFERRED",
      "extractionConfig": {
        "llmExtractionConfig": {
          "definition": "Primary topic of the conversation",
          "llmExtractionInstruction": "Identify the main topic discussed"
        }
      }
    }
  ]
}

Saat Anda menghilangkanextractionType, defaultnya adalahLLM_INFERRED.

Isolasi ekstraksi dan konsolidasi

STRICTLY_CONSISTENTkunci melakukan lebih dari sekadar melewatkan inferensi LLM. Mereka mengelompokkan peristiwa berdasarkan nilai deterministik mereka selama ekstraksi. Acara dengan nilai berbeda diproses secara terpisah. Konsolidasi mengikuti aturan yang sama. Catatan dari satu grup nilai tidak pernah bergabung dengan catatan dari grup lain.

Contoh Python berikut menunjukkan sesi dukungan dengan dua kunci deterministik (departmentdanpriority):

# Event 1: high-priority billing inquiry
agentcore_client.create_event(
    memoryId="mem-support-abc123",
    actorId="customer-123",
    sessionId="session-escalation-001",
    payload=[{"conversational": {"role": "USER",
        "content": {"text": "I'm seeing duplicate charges on my invoice and it's blocking our deployment."}}}],
    metadata={
        "department": {"stringValue": "billing"},
        "priority": {"stringValue": "high"}
    }
)

# Event 2: also high-priority billing (same deterministic values as Event 1)
agentcore_client.create_event(
    memoryId="mem-support-abc123",
    actorId="customer-123",
    sessionId="session-escalation-001",
    payload=[{"conversational": {"role": "USER",
        "content": {"text": "The charges appeared after we upgraded from standard to enterprise tier last week."}}}],
    metadata={
        "department": {"stringValue": "billing"},
        "priority": {"stringValue": "high"}
    }
)

# Event 3: high-priority engineering (same priority, different department)
agentcore_client.create_event(
    memoryId="mem-support-abc123",
    actorId="customer-123",
    sessionId="session-escalation-001",
    payload=[{"conversational": {"role": "USER",
        "content": {"text": "Your team found a provisioning bug that triggered the duplicate charge."}}}],
    metadata={
        "department": {"stringValue": "engineering"},
        "priority": {"stringValue": "high"}
    }
)

# Event 4: low-priority billing (same department as Events 1-2, different priority)
agentcore_client.create_event(
    memoryId="mem-support-abc123",
    actorId="customer-123",
    sessionId="session-escalation-001",
    payload=[{"conversational": {"role": "USER",
        "content": {"text": "Also, can you update the billing contact email on file when you get a chance?"}}}],
    metadata={
        "department": {"stringValue": "billing"},
        "priority": {"stringValue": "low"}
    }
)

Sistem mengelompokkan peristiwa dengan kombinasi yang tepat dari semua nilai kunci deterministik:

Semua nilai kunci deterministik harus cocok untuk peristiwa yang akan dikelompokkan. Kueri dengan department=billing AND hanya priority=high mengembalikan fakta tagihan duplikat yang mendesak. Peristiwa lainnya berada di partisi terpisah. Catatan dari kombinasi nilai yang berbeda tidak pernah bergabung selama konsolidasi.

Batasan

Bagaimana kunci yang diindeks dan kunci skema berinteraksi

Hubungan antara kunci yang diindeks dan kunci skema menentukan bagaimana metadata berperilaku:

Bagaimana metadata mengalir dari peristiwa ke catatan memori

Metadata acara hanya menerima stringValue entri. Dukungan catatan memori stringValuestringListValue, dan numberValue jenis - diisi oleh LLM selama ekstraksi atau disediakan langsung melalui API Batch. Jenis dateTimeValue dicadangkan untuk bidang yang dihasilkan sistem (x-amz-agentcore-memory-createdAtdanx-amz-agentcore-memory-updatedAt). Hanya kunci yang ditentukan dalam strategi yang metadataSchema diisi pada catatan yang diekstraksi — kunci metadata peristiwa yang tidak ada dalam skema diabaikan. Untuk batas masuk, lihatKuota.

System-generated metadata

Setiap catatan memori membawa bidang sistem ini, dapat dikueri dengan operator filter yang sama:

Anda tidak perlu mendeklarasikan ini sebagai kunci yang diindeks — kunci tersebut selalu tersedia untuk difilter. dateTimeValueBidang yang dihasilkan sistem ini mendukung BEFORE dan AFTER operator, memungkinkan kueri rentang waktu tanpa mengharuskan Anda mendeklarasikan kunci yang diindeks datetime.

Prasyarat

Sebelum mengonfigurasi pemfilteran metadata, pastikan Anda memiliki:

Langkah 1: Buat memori dengan kunci yang diindeks dan skema metadata

Berikut ini membuat memori dukungan pelanggan dengan lima kunci yang diindeks dan skema metadata. priority,agent_type, dan sentiment didefinisikan dalam skema metadata strategi - LLM mengekstrak nilai-nilainya dari konten percakapan. Perhatikan bahwa sentiment ada dalam skema tetapi tidak di deklarasikan sebagai kunci yang diindeks: LLM memperoleh nilainya dari percakapan dan mengisinya pada catatan, tetapi tidak dapat digunakan dalam ekspresi filter. tags(STRINGLIST), channel (STRING), dan ticket_id (STRING) dideklarasikan sebagai kunci yang diindeks tetapi tidak ada dalam skema — kunci tersebut tidak diisi selama ekstraksi berbasis peristiwa tetapi dapat disediakan melalui Batch API.

aws bedrock-agentcore-control create-memory \
  --name "CustomerSupportMemory" \
  --event-expiry-duration 30 \
  --indexed-keys '[
    {"key": "priority",   "type": "STRING"},
    {"key": "agent_type", "type": "STRING"},
    {"key": "tags",       "type": "STRINGLIST"},
    {"key": "channel",    "type": "STRING"},
    {"key": "ticket_id",  "type": "STRING"}
  ]' \
  --memory-strategies '[
    {
      "semanticMemoryStrategy": {
        "name": "SupportSemanticStrategy",
        "description": "Captures support interaction details",
        "namespaceTemplates": ["support/{actorId}"],
        "memoryRecordSchema": {
          "metadataSchema": [
            {
              "key": "priority",
              "type": "STRING",
              "extractionConfig": {
                "llmExtractionConfig": {
                  "definition": "Issue priority level based on customer impact. Values range from critical (most severe) to low (least severe).",
                  "llmExtractionInstruction": "LATEST_VALUE",
                  "validation": {
                    "stringValidation": {
                      "allowedValues": ["critical", "high", "medium", "low"]
                    }
                  }
                }
              }
            },
            {
              "key": "agent_type",
              "type": "STRING",
              "extractionConfig": {
                "llmExtractionConfig": {
                  "definition": "Support agent classification.",
                  "llmExtractionInstruction": "Prefer the most specialized agent type. Hierarchy: specialist > tier3 > tier2 > tier1 > bot."
                }
              }
            },
            {
              "key": "sentiment",
              "type": "STRING",
              "extractionConfig": {
                "llmExtractionConfig": {
                  "definition": "Customer sentiment during the interaction.",
                  "llmExtractionInstruction": "LATEST_VALUE",
                  "validation": {
                    "stringValidation": {
                      "allowedValues": ["positive", "neutral", "negative", "frustrated"]
                    }
                  }
                }
              }
            }
          ]
        }
      }
    }
  ]'

Langkah 2: Verifikasi konfigurasi

Gunakan GetMemory untuk mengonfirmasi bahwa kunci yang diindeks dan skema metadata diterima:

aws bedrock-agentcore-control get-memory --memory-id "<memory-id>"

Langkah 3: Tambahkan metadata selama konsumsi

Ada dua jalur untuk mendapatkan metadata ke catatan memori. Dengan konsumsi berbasis ekstraksi (CreateEventatauIngestData), LLM mengisi metadata pada catatan yang diekstraknya. Dengan pembuatan rekaman langsung (BatchCreateMemoryRecordsatauBatchUpdateMemoryRecords), Anda menyediakan metadata secara eksplisit.

Event-driven menelan

Lampirkan stringValue metadata ke acara pada waktu pembuatan. LLM menggunakan skema metadata strategi untuk mengekstrak dan mengisi metadata pada catatan memori yang dihasilkan. Hanya kunci yang ditentukan dalam strategi yang metadataSchema diisi pada catatan yang dihasilkan — kunci metadata peristiwa yang tidak ada dalam skema diabaikan selama ekstraksi.

aws bedrock-agentcore create-event \
  --memory-id "<memory-id>" \
  --actor-id "customer-123" \
  --session-id "session-001" \
  --event-timestamp "$(date -u +"%Y-%m-%dT%H:%M:%S.%3NZ")" \
  --metadata '{
    "priority":  {"stringValue": "high"},
    "channel":   {"stringValue": "email"},
    "ticket_id": {"stringValue": "TKT-5001"}
  }' \
  --payload '[
    {"conversational": {"role": "USER",      "content": {"text": "I have a billing issue that is blocking my production deployment"}}},
    {"conversational": {"role": "ASSISTANT", "content": {"text": "I understand this is urgent. Let me escalate to our billing specialist team."}}}
  ]'

Dalam contoh ini, priority ada dalam strategimetadataSchema, sehingga nilainya menyebar ke catatan memori. channeldan tidak ticket_id ada dalam skema, jadi mereka diabaikan selama ekstraksi. LLM juga menyimpul agent_type kan (kemungkinan "specialist" berdasarkan eskalasi) dan sentiment (kemungkinan"frustrated") dari konten percakapan — kunci skema ini diisi meskipun tidak disediakan sebagai metadata peristiwa.

Ekstraksi metadata implisit dari konten percakapan

Metadata peristiwa tidak diperlukan untuk kunci skema untuk menghasilkan nilai. Ketika kunci skema tidak memiliki metadata yang cocok pada peristiwa asal, LLM memperoleh nilai sepenuhnya dari konten percakapan. Ini menggunakan kunci definition dan llmExtractionInstruction untuk menentukan nilainya. Ini berguna untuk dimensi yang hanya ada dalam percakapan itu sendiri — tanpa mengharuskan pemanggil untuk menyediakannya pada waktu pembuatan acara.

Menggunakan memori dukungan pelanggan yang sama dari Langkah 1, acara berikut tidak memiliki metadata sama sekali:

aws bedrock-agentcore create-event \
  --memory-id "<memory-id>" \
  --actor-id "customer-789" \
  --session-id "session-002" \
  --event-timestamp "$(date -u +"%Y-%m-%dT%H:%M:%S.%3NZ")" \
  --payload '[
    {"conversational": {"role": "USER",      "content": {"text": "My production deployment is down because of a billing hold on our account"}}},
    {"conversational": {"role": "ASSISTANT", "content": {"text": "I understand the urgency. Let me connect you with our billing specialist team right away."}}}
  ]'

LLM menganalisis konten percakapan dan mengisi ketiga kunci skema pada catatan memori yang diekstraksi -priority,agent_type, dan sentiment - meskipun tidak ada yang disediakan sebagai metadata acara:

{
  "content": {"text": "Customer reported a production outage caused by a billing hold. Escalated to billing specialist."},
  "metadata": {
    "priority":   {"stringValue": "critical"},
    "agent_type": {"stringValue": "specialist"},
    "sentiment":  {"stringValue": "frustrated"}
  }
}

Aturan validasi masih berlaku — output LLM dibatasi pada nilai yang diizinkan yang Anda tentukan terlepas dari apakah nilai tersebut berasal dari metadata peristiwa atau inferensi konten.

Bagaimana LLM menyelesaikan konflik lintas acara

Ketika beberapa peristiwa dalam sesi membawa nilai yang berbeda untuk kunci metadata yang sama, LLM menggunakan. llmExtractionInstruction Ini menentukan nilai mana yang akan disimpan pada catatan memori yang dihasilkan.

Misalnya, pertimbangkan sesi dukungan di mana acara pertama memiliki priority: "low" dan acara selanjutnya meningkat. priority: "critical" LLM menyelesaikan ini berdasarkan instruksi:

Contoh lain: untuk agent_type dengan instruksi “Lebih suka jenis agen yang paling khusus. Hierarki: spesialis > tier3 > tier2 > tier1 > bot”, jika sesi dimulai dengan bot dan meningkat ke agen tier2, catatan memori akan diterima. agent_type: "tier2"

Konsumsi metadata deterministik

Tombol yang dikonfigurasi STRICTLY_CONSISTENT mengikuti jalur penyerapan yang berbeda. Nilai yang Anda berikan pada acara adalah nilai yang mendarat di catatan yang dihasilkan. Tidak ada inferensi LLM dan tidak ada resolusi konflik.

AgentCore Memori mengelompokkan peristiwa berdasarkan nilai kunci deterministiknya sebelum ekstraksi. Misalnya, peristiwa yang ditandai department: "engineering" diproses secara terpisah dari peristiwa yang ditandaidepartment: "finance".

Konsolidasi beroperasi dalam kelompok-kelompok ini. Rekaman yang compliance_level: "hipaa" tidak pernah menyatu dengan catatan berlabelcompliance_level: "standard". Ini membuat kunci deterministik ideal untuk:

Jika suatu peristiwa tidak memiliki nilai untuk kunci deterministik, kunci tersebut tidak ada pada catatan yang dihasilkan.

Jalur tulis langsung (BatchCreateMemoryRecordsdanBatchUpdateMemoryRecords) memotong ekstraksi. Jenis STRICTLY_CONSISTENT ekstraksi tidak berpengaruh pada mereka. Menyediakan metadata secara langsung seperti yang sudah Anda lakukan untuk API tersebut.

Pembuatan rekaman langsung dengan Batch API

Untuk impor basis pengetahuan, strategi yang dikelola sendiri, atau konten pra-proses, gunakan BatchCreateMemoryRecords (atauBatchUpdateMemoryRecords) untuk menyediakan metadata secara eksplisit. Ini melewati ekstraksi LLM sepenuhnya - pemanggil mengontrol nilai metadata.

Cara metadata ditangani pada catatan yang dibuat batch tergantung pada apakah Anda memberikan: memoryStrategyId

Contoh berikut membuat catatan tanpamemoryStrategyId, menyimpan semua metadata yang disediakan:

aws bedrock-agentcore batch-create-memory-records \
  --memory-id "<memory-id>" \
  --records '[{
    "requestIdentifier": "import-001",
    "namespaces": ["support/customer-456"],
    "content": {"text": "Customer prefers phone support for urgent billing issues"},
    "timestamp": "2026-01-15T10:00:00Z",
    "metadata": {
      "priority":   {"stringValue": "high"},
      "agent_type": {"stringValue": "billing_agent"},
      "channel":    {"stringValue": "phone"},
      "ticket_id":  {"stringValue": "TKT-7890"}
    }
  }]'

Untuk menegakkan konsistensi skema, sertakanmemoryStrategyId. Dalam hal ini, hanya kunci yang ada dalam strategi itu yang memoryRecordSchema dipertahankan:

aws bedrock-agentcore batch-create-memory-records \
  --memory-id "<memory-id>" \
  --records '[{
    "requestIdentifier": "import-002",
    "namespaces": ["support/customer-456"],
    "memoryStrategyId": "<strategy-id>",
    "content": {"text": "Billing dispute resolved after account credit applied"},
    "timestamp": "2026-01-16T14:00:00Z",
    "metadata": {
      "priority":   {"stringValue": "medium"},
      "agent_type": {"stringValue": "billing_agent"},
      "channel":    {"stringValue": "phone"}
    }
  }]'

Dalam contoh kedua, jika skema strategi hanya mendefinisikanpriority,, dan agent_typesentiment, kemudian diam-diam channel dihapus dari catatan yang disimpan.

Memperbarui catatan dengan BatchUpdateMemoryRecords

BatchUpdateMemoryRecordsmengikuti perilaku pemfilter memoryStrategyId an metadata yang sama sepertiBatchCreateMemoryRecords. Contoh berikut memperbarui konten dan metadata rekaman yang ada:

aws bedrock-agentcore batch-update-memory-records \
  --memory-id "<memory-id>" \
  --records '[{
    "memoryRecordId": "<record-id>",
    "namespaces": ["support/customer-456"],
    "content": {"text": "Customer prefers phone support for urgent billing issues. Account credit applied."},
    "metadata": {
      "priority":   {"stringValue": "critical"},
      "agent_type": {"stringValue": "billing_agent"},
      "channel":    {"stringValue": "phone"}
    }
  }]'

Langkah 4: Kueri dengan filter metadata

Filter metadata diterapkan sebelum pencarian kesamaan vektor berjalan (pra-pemfilteran). Ini mengurangi kandidat yang ditetapkan terlebih dahulu. Akibatnya, pencarian K-nearest tetangga (KNN) beroperasi pada subset yang lebih kecil dan lebih relevan.

Struktur filter

Setiap filter adalah { left, operator, right } ekspresi:

{
  "left":     { "metadataKey": "priority" },
  "operator": "EQUALS_TO",
  "right":    { "metadataValue": { "stringValue": "high" } }
}

Hingga 5 filter dapat digabungkan per kueri. Beberapa filter diterapkan dengan AND logika.

Operator yang didukung

Catatan: Filter metadata acara hanya pada ListEvents dukunganEXISTS,NOT_EXISTS, danEQUALS_TO, dan sajastringValue.

Ambil dengan filter metadata (pencarian semantik+pra-filter)

AktifRetrieveMemoryRecords, metadataFilters bersarang di dalamsearchCriteria. Contoh berikut mencakup hasil ke catatan prioritas tinggi dari tahun berjalan sebelum penelusuran semantik cocok dengan “masalah penagihan”:

aws bedrock-agentcore retrieve-memory-records \
  --memory-id "<memory-id>" \
  --namespace "support/customer-123" \
  --search-criteria '{
    "searchQuery": "billing issues",
    "topK": 10,
    "metadataFilters": [
      {
        "left":     {"metadataKey": "priority"},
        "operator": "EQUALS_TO",
        "right":    {"metadataValue": {"stringValue": "high"}}
      },
      {
        "left":     {"metadataKey": "x-amz-agentcore-memory-createdAt"},
        "operator": "AFTER",
        "right":    {"metadataValue": {"dateTimeValue": "2026-01-01T00:00:00Z"}}
      }
    ]
  }'

Menggabungkan filter metadata khusus dengan stempel waktu yang dihasilkan sistem memadatkan kandidat yang ditetapkan di sepanjang dua dimensi — prioritas bisnis dan kebaruan — sebelum pencarian kesamaan berjalan.

Daftar dengan filter metadata (tidak ada pencarian semantik)

ListMemoryRecordsmenyediakan pemfilteran metadata tanpa pencarian semantik. Ini berguna ketika Anda perlu menghitung catatan yang cocok dengan kriteria metadata tertentu — misalnya, mencantumkan semua catatan prioritas tinggi untuk pelanggan, atau menarik semua catatan yang dibuat setelah tanggal tertentu.

AktifListMemoryRecords, metadataFilters adalah parameter tingkat atas:

aws bedrock-agentcore list-memory-records \
  --memory-id "<memory-id>" \
  --namespace "support/customer-123" \
  --metadata-filters '[
    {
      "left":     {"metadataKey": "priority"},
      "operator": "EQUALS_TO",
      "right":    {"metadataValue": {"stringValue": "high"}}
    },
    {
      "left":     {"metadataKey": "x-amz-agentcore-memory-createdAt"},
      "operator": "AFTER",
      "right":    {"metadataValue": {"dateTimeValue": "2026-01-20T00:00:00Z"}}
    }
  ]'

Menggabungkan beberapa filter

Kueri ini mencakup pengambilan ke diskusi ekuitas Q3 2026 dalam namespace klien tertentu:

{
  "searchQuery": "portfolio rebalancing strategy",
  "topK": 10,
  "metadataFilters": [
    {
      "left":     {"metadataKey": "asset_class"},
      "operator": "EQUALS_TO",
      "right":    {"metadataValue": {"stringValue": "equities"}}
    },
    {
      "left":     {"metadataKey": "x-amz-agentcore-memory-createdAt"},
      "operator": "AFTER",
      "right":    {"metadataValue": {"dateTimeValue": "2026-07-01T00:00:00Z"}}
    },
    {
      "left":     {"metadataKey": "x-amz-agentcore-memory-createdAt"},
      "operator": "BEFORE",
      "right":    {"metadataValue": {"dateTimeValue": "2026-09-30T23:59:59Z"}}
    }
  ]
}

Nilai filter untuk stempel waktu harus dalam UTC (format ISO 8601). Layanan menormalkan semua stempel waktu yang disimpan ke UTC sebelum perbandingan, jadi selalu ungkapkan nilai filter dalam UTC.

Langkah 5: Kembangkan skema metadata Anda

AgentCore Memori mendukung evolusi skema sehingga Anda dapat menyesuaikan konfigurasi metadata Anda saat kebutuhan Anda berubah.

Tambahkan kunci yang diindeks

Anda dapat menambahkan kunci baru yang diindeks ke memori kapan saja:

aws bedrock-agentcore-control update-memory \
  --memory-id "<memory-id>" \
  --add-indexed-keys '[
    {"key": "customer_segment", "type": "STRING"}
  ]'

Kunci baru segera tersedia untuk acara masuk dan catatan memori. Catatan yang ada tidak diisi ulang — hanya catatan baru atau yang diperbarui yang membawa kunci baru. Anda tidak dapat menghapus kunci yang diindeks sebelumnya, yang mencegah hilangnya kemampuan pemfilteran secara tidak sengaja pada data yang ada.

Ubah skema metadata strategi

Anda dapat dengan bebas menambahkan, menghapus, atau memperbarui entri dalam skema metadata strategi. Ini mengontrol metadata apa yang diambil LLM dari percakapan ke depan.

Misalnya, untuk menambahkan resolution_type bidang baru ke strategi yang ada:

aws bedrock-agentcore-control update-memory \
  --memory-id "<memory-id>" \
  --memory-strategies '{
    "modifyMemoryStrategies": [
      {
        "memoryStrategyId": "<strategy-id>",
        "memoryRecordSchema": {
          "metadataSchema": [
            {
              "key": "resolution_type",
              "type": "STRING",
              "extractionConfig": {
                "llmExtractionConfig": {
                  "definition": "How the customer support issue was resolved",
                  "validation": {
                    "stringValidation": {
                      "allowedValues": ["refund", "replacement", "escalation", "self-resolved"]
                    }
                  }
                }
              }
            }
          ]
        }
      }
    ]
  }'

Anda juga dapat menghapus kunci dari skema metadata strategi jika Anda tidak lagi ingin LLM mengekstrak bidang itu. Menghapus entri skema menghentikan ekstraksi untuk catatan baru tetapi tidak memengaruhi metadata yang sudah ada pada catatan yang ada.

Catatan memori yang ada tidak secara retroaktif menerima LLM-extracted bidang baru. Namun, ketika memori yang lebih lama dikonsolidasikan dengan yang lebih baru selama siklus hidup memori normal, catatan konsolidasi diekstraksi ulang menggunakan skema saat ini dan akan menyertakan bidang metadata baru.

Kuota

Praktik terbaik

Anti-patterns untuk menghindari