update_memory async ¶

async def update_memory(
    self,
    memory_id: "capo_bedrock_agentcore_control.types.memory_id.MemoryId",
    *,
    config_overrides: Optional[AsyncBedrockAgentCoreControlClientConfig] = None,
    client_token: Optional[
        "capo_bedrock_agentcore_control.types.non_empty_string.NonEmptyString"
    ] = None,
    description: Optional[
        "capo_bedrock_agentcore_control.types.description.Description"
    ] = None,
    event_expiry_duration: Optional[int] = None,
    memory_execution_role_arn: Optional[
        "capo_bedrock_agentcore_control.types.arn.Arn"
    ] = None,
    memory_strategies: Optional[
        "capo_bedrock_agentcore_control.types.modify_memory_strategies.ModifyMemoryStrategies"
    ] = None,
    add_indexed_keys: Optional[
        "capo_bedrock_agentcore_control.types.indexed_keys_list.IndexedKeysList"
    ] = None,
    namespace_keys: Optional[
        "capo_bedrock_agentcore_control.types.namespace_keys_list.NamespaceKeysList"
    ] = None,
    stream_delivery_resources: Optional[
        "capo_bedrock_agentcore_control.types.stream_delivery_resources.StreamDeliveryResources"
    ] = None,
) -> "capo_bedrock_agentcore_control.types.update_memory_output.UpdateMemoryOutput":
    """<p>Update an Amazon Bedrock AgentCore Memory resource memory.</p>

    Args:
        client_token: <p>A client token is used for keeping track of idempotent requests. It can contain a session id which can be around 250 chars, combined with a unique Amazon Web Services identifier.</p>
        memory_id: <p>The unique identifier of the memory to update.</p>
        description: <p>The updated description of the AgentCore Memory resource.</p>
        event_expiry_duration: <p>The number of days after which memory events will expire, between 7 and 365 days.</p>
        memory_execution_role_arn: <p>The ARN of the IAM role that provides permissions for the AgentCore Memory resource.</p>
        memory_strategies: <p>The memory strategies to add, modify, or delete.</p>
        add_indexed_keys: <p>Additional metadata keys to index. Previously indexed keys cannot be removed.</p>
        namespace_keys: <p>The namespace variable key definitions with validation rules for this memory. This value fully replaces the existing set — any key you omit is removed. Any referenced <code>namespaceKey</code> omission will throw ValidationException.</p>
        stream_delivery_resources: <p>Configuration for streaming memory record data to external resources.</p>

    Raises:
        capo_bedrock_agentcore_control.errors.access_denied_exception.AccessDeniedException: <p>This exception is thrown when a request is denied per access permissions</p>
        capo_bedrock_agentcore_control.errors.conflict_exception.ConflictException: <p>This exception is thrown when there is a conflict performing an operation</p>
        capo_bedrock_agentcore_control.errors.resource_not_found_exception.ResourceNotFoundException: <p>This exception is thrown when a resource referenced by the operation does not exist</p>
        capo_bedrock_agentcore_control.errors.service_exception.ServiceException: <p>An internal error occurred.</p>
        capo_bedrock_agentcore_control.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>This exception is thrown when a request is made beyond the service quota</p>
        capo_bedrock_agentcore_control.errors.throttled_exception.ThrottledException: <p>API rate limit has been exceeded.</p>
        capo_bedrock_agentcore_control.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by the service.</p>
        capo_bedrock_agentcore_control.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_bedrock_agentcore_control.types.update_memory_input.UpdateMemoryInput]",
    ) -> AsyncOperationResponse[
        "capo_bedrock_agentcore_control.types.update_memory_output.UpdateMemoryOutput"
    ]:
        import capo_bedrock_agentcore_control._operations.amazon_bedrock_agent_core_control.update_memory

        (
            output,
            http_response,
        ) = await capo_bedrock_agentcore_control._operations.amazon_bedrock_agent_core_control.update_memory.async_update_memory(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_bedrock_agentcore_control.types.update_memory_input.UpdateMemoryInput",
    ) -> dict[str, Any]:
        import capo_bedrock_agentcore_control.types.update_memory_input

        return capo_bedrock_agentcore_control.types.update_memory_input.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_bedrock_agentcore_control.types.update_memory_output.UpdateMemoryOutput",
    ) -> dict[str, Any]:
        import capo_bedrock_agentcore_control.types.update_memory_output

        return capo_bedrock_agentcore_control.types.update_memory_output.redact_sensitive(
            output
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "UpdateMemory", redact_input=_redact_input, redact_output=_redact_output
        ),
    )
    input_: capo_bedrock_agentcore_control.types.update_memory_input.UpdateMemoryInput = {
        "memory_id": memory_id
    }
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token
    if description is not None:
        input_["description"] = description
    if event_expiry_duration is not None:
        input_["event_expiry_duration"] = event_expiry_duration
    if memory_execution_role_arn is not None:
        input_["memory_execution_role_arn"] = memory_execution_role_arn
    if memory_strategies is not None:
        input_["memory_strategies"] = memory_strategies
    if add_indexed_keys is not None:
        input_["add_indexed_keys"] = add_indexed_keys
    if namespace_keys is not None:
        input_["namespace_keys"] = namespace_keys
    if stream_delivery_resources is not None:
        input_["stream_delivery_resources"] = stream_delivery_resources

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output