Metadata terstruktur untuk ingatan 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 dekat artinya. 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 kemudian melaluiUpdateMemory). Kunci yang diindeks disimpan dalam format yang dioptimalkan untuk pemfilteran kueri cepat. Hanya kunci yang diindeks yang dapat dikueri di on dan. metadataFilters ListMemoryRecords RetrieveMemoryRecords

Contoh berikut mendeklarasikan dua kunci diindeks:

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

typeNilai 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 itu. Untuk detail lebih lanjut tentang mengembangkan skema Anda dari waktu ke waktu, lihat. Langkah 5: Kembangkan skema metadata Anda

Skema metadata (per strategi)

Strategi Memori secara opsional dapat memiliki skema metadata yang dideklarasikan dalam. memoryRecordSchema.metadataSchema Skema metadata memberi tahu LLM metadata apa yang akan 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_CONSISTEN)

Kunci metadata deterministik berisi nilai yang sudah diketahui aplikasi Anda saat membuat acara. Nilai-nilai ini disalin persis 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 menghasilkan "eng" pada satu rekaman dan "Engineering" 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 keduanya STRICTLY_CONSISTENT dan jenis ekstraksi: LLM_INFERRED

{
  "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"
        }
      }
    }
  ]
}

Ketika Anda menghilangkanextractionType, defaultnya adalahLLM_INFERRED.

Ekstraksi dan isolasi konsolidasi

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

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

# 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 acara yang akan dikelompokkan. Kueri dengan department=billing AND hanya priority=high mengembalikan fakta biaya duplikat yang mendesak. Acara 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 peristiwa hanya menerima entri. stringValue Dukungan catatan memoristringValue,stringListValue, dan numberValue jenis — diisi oleh LLM selama ekstraksi atau dipasok langsung melalui API Batch. dateTimeValueJenis ini dicadangkan untuk bidang yang dihasilkan sistem (x-amz-agentcore-memory-createdAtdanx-amz-agentcore-memory-updatedAt). Hanya kunci yang ditentukan dalam strategi yang diisi pada catatan yang diekstraksi — kunci metadata peristiwa yang tidak ada dalam skema diabaikan. metadataSchema Untuk batas masuk, lihatKuota.

System-generated metadata

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

Anda tidak perlu mendeklarasikan ini sebagai kunci yang diindeks - mereka selalu tersedia untuk pemfilteran. 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, verifikasi bahwa Anda memiliki:

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

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

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: Menelan data dengan metadata

Ada dua jalur untuk mendapatkan metadata ke catatan memori.

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 metadataSchema yang 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 ticket_id tidak dalam skema, sehingga mereka diabaikan selama ekstraksi. LLM juga menyimpulkan agent_type (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 yang berasal, 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 penelepon untuk menyediakannya pada waktu pembuatan acara.

Menggunakan memori dukungan pelanggan yang sama dari Langkah 1, peristiwa 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 peristiwa:

{
  "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 ke nilai yang diizinkan yang Anda tentukan terlepas dari apakah nilainya berasal dari metadata peristiwa atau inferensi konten.

Bagaimana LLM menyelesaikan konflik lintas peristiwa

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

Misalnya, pertimbangkan sesi dukungan di mana acara pertama terjadi 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 didapat. agent_type: "tier2"

Konsumsi metadata deterministik

Kunci dikonfigurasi sebagai STRICTLY_CONSISTENT mengikuti jalur konsumsi yang berbeda. Nilai yang Anda berikan pada acara tersebut adalah nilai yang mendarat di catatan yang dihasilkan. Tidak ada kesimpulan LLM dan tidak ada resolusi konflik.

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

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

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

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

Pembuatan rekaman langsung dengan API Batch

Untuk impor berbasis pengetahuan, strategi yang dikelola sendiri, atau konten yang telah diproses sebelumnya, gunakan BatchCreateMemoryRecords (atau) untuk memasok metadata secara eksplisit. BatchUpdateMemoryRecords Ini melewati ekstraksi LLM sepenuhnya — pemanggil mengontrol nilai metadata.

Bagaimana metadata ditangani pada catatan yang dibuat batch tergantung pada apakah Anda menyediakan: 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, sertakan. memoryStrategyId Dalam hal ini, hanya kunci yang ada dalam strategi itu memoryRecordSchema yang 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 dijatuhkan dari catatan yang disimpan.

Memperbarui catatan dengan BatchUpdateMemoryRecords

BatchUpdateMemoryRecordsmengikuti perilaku pemfilteran memoryStrategyId metadata yang sama seperti. BatchCreateMemoryRecords 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-penyaringan). Ini mengurangi set kandidat 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 peristiwa hanya pada ListEvents dukunganEXISTS,, dan NOT_EXISTSEQUALS_TO, dan hanya. stringValue

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

OnRetrieveMemoryRecords, 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 kustom dengan stempel waktu yang dihasilkan sistem memadatkan kandidat yang ditetapkan 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.

OnListMemoryRecords, 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 nyatakan 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 penyaringan yang tidak disengaja pada data yang ada.

Memodifikasi skema metadata strategi

Anda dapat dengan bebas menambahkan, menghapus, atau memperbarui entri dalam skema metadata strategi. Ini mengontrol metadata apa yang diekstrak 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 surut menerima LLM-extracted bidang baru. Namun, ketika memori 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